﻿using System;
using System.Collections.Generic;
using System.Collections;
using System.Linq;
using System.Text;
using System.Globalization;
using System.Text.RegularExpressions;
using SPMS.Utility.Properties;

namespace SPMS.Utility
{
    /// <summary>
    /// 字符串处理辅助类
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <history>
    /// [zanezeng]   2008-9-23 4:31 PM    Created
    /// </history>
    public static class StringUtility
    {
        #region ---Utility

        /// <summary>
        /// 判断字符串是否为NULL或者为空字符串
        /// </summary>
        /// <param name="source">需要检查的源字符串</param>
        /// <returns>
        /// 	<c>true</c>：字符串为Null或者长度为0<br/>
        /// 	<c>false</c>：字符串不为空且长度大于0
        /// </returns>
        /// <remarks>传入的字符串为Null或者全部由空格组成则认为是空字符串</remarks>
        /// <history>
        /// [zanezeng]   2008-9-23 9:39 PM    Created
        /// </history>
        public static bool IsNullOrEmpty( string source )
        {
            //直接调用字符串的函数
            return string.IsNullOrEmpty( source );
        }

        /// <summary>
        /// 判断指定的字符串数组是否为空数组或者数组的内容全部为空字符串
        /// </summary>
        /// <param name="soruce">需要检查的源字符串数组</param>
        /// <returns>
        /// 	<c>true</c>：指定的字符串数组为空数组或者数组的内容全部为空字符串<br/>
        /// 	<c>false</c>：指定的字符串数组不是空数组并且数组中的内容至少有一个不是空字符串
        /// </returns>
        /// <remarks></remarks>
        /// <history>
        /// [ZaneZeng]               2009-5-5 14:33    创建
        /// </history>
        public static bool IsNullOrEmpty( string[] soruce )
        {
            //判断是否为空数组
            if (null == soruce || 0 == soruce.Length)
            {
                //返回为空数组
                return true;
            }

            //循环判断
            foreach (string element in soruce)
            {
                //判断是否为空字符串
                if (!string.IsNullOrEmpty( element ))
                {
                    //返回不是空数组
                    return false;
                }
            }

            //默认返回为空数组
            return true;
        }

        /// <summary>
        /// 判断目标字符串中是否包含非空字符
        /// </summary>
        /// <param name="source">需要检查的源字符串</param>
        /// <returns>
        /// 	<c>true</c>：包含非空字符<br/>
        /// 	<c>false</c>：为空或者包含空字符
        /// </returns>
        /// <remarks></remarks>
        /// <history>
        /// [zanezeng]   2008-9-23 4:32 PM    Created
        /// </history>
        public static bool HasText( string source )
        {
            //处理源字符串
            source = Trim( source );

            //返回
            return !string.IsNullOrEmpty( source );
        }

        /// <summary>
        /// 获得安全字符串，如果输入的字符串为NULL，那么返回空字符串
        /// </summary>
        /// <param name="source">需要转换的源字符串</param>
        /// <returns>字符串实例</returns>
        /// <remarks></remarks>
        /// <history>
        /// [zanezeng]   2008-9-23 9:51 PM    Created
        /// </history>
        public static string GetSafeString( string source )
        {
            return (null == source) ? string.Empty : source;
        }

        /// <summary>
        /// 将指定对象转化为字符串
        /// </summary>
        /// <param name="source">需要转化的对象</param>
        /// <returns>如果对象为空，则返回空字符串</returns>
        /// <remarks></remarks>
        /// <history>
        /// [zanezeng]   2008-10-15 3:57 PM    Created
        /// </history>
        public static string ToString( object source )
        {
            //判断是否为NULL
            if (null == source)
            {
                //返回空字符串
                return string.Empty;
            }

            //判断是否为字符串
            if (source is string)
            {
                //直接返回
                return (string)source;
            }

            //返回
            return source.ToString();
        }

        /// <summary>
        /// 使用单引号包围元字符串
        /// </summary>
        /// <param name="source">需要处理的源字符串</param>
        /// <returns>包含处理结果的新字符串实例，如果输入的字符串为<c>null</c>引用或者为空字符串，则返回''。</returns>
        /// <remarks>
        /// 	<example>ABC =&gt; 'ABC'</example>
        /// </remarks>
        /// <history>
        /// [zanezeng]   2008-9-25 10:14 AM    Created
        /// </history>
        public static string Quote( string source )
        {
            //返回
            return string.Format( "'{0}'", source );

        }

        /// <summary>
        /// 获得指定限定名称的非限定名称
        /// </summary>
        /// <param name="qualifiedName">限定名称</param>
        /// <returns>
        /// 包含非限定名称的新字符串实例<br/>
        /// 如果输入的限定名称为Null或者为空字符串，则返回空字符串。如果输入的限定名称为非限定名称，则返回输入限定名称的新实例。
        /// </returns>
        /// <remarks>分隔符为：[.]
        /// <example>例如 输入GrapeCity.Leyser.Common输出Common</example>
        /// </remarks>
        /// <history>
        /// [zanezeng]   2008-9-25 10:16 AM    Created
        /// </history>
        public static string UnQualify( string qualifiedName )
        {
            //判断是否为空字符串
            if (string.IsNullOrEmpty( qualifiedName ))
            {
                return qualifiedName;
            }

            //去掉开头的单引号
            qualifiedName = qualifiedName.TrimStart( DEFAULT_QUALIFIER );

            //去掉结尾的单引号
            qualifiedName = qualifiedName.TrimEnd( DEFAULT_QUALIFIER );

            //返回
            return qualifiedName;
        }

        /// <summary>
        /// 以指定字符作为分隔符，获得指定限定名称的非限定名称
        /// </summary>
        /// <param name="qualifiedName">限定名称</param>
        /// <param name="separator">分隔符</param>
        /// <returns>
        /// 包含非限定名称的新字符串实例<br/>
        /// 如果输入的限定名称为Null或者为空字符串，则返回空字符串。如果输入的限定名称为非限定名称，则返回输入限定名称的新实例。
        /// </returns>
        /// <remarks></remarks>
        /// <history>
        /// [zanezeng]   2008-9-25 10:21 AM    Created
        /// </history>
        public static string[] UnQualify( string qualifiedName, char separator )
        {
            //判断是否为空字符串
            if (string.IsNullOrEmpty( qualifiedName ))
            {
                return new string[] { string.Empty, string.Empty };
            }

            //去掉开头的单引号
            qualifiedName = qualifiedName.TrimStart( DEFAULT_QUALIFIER );

            //去掉结尾的单引号
            qualifiedName = qualifiedName.TrimEnd( DEFAULT_QUALIFIER );

            //返回
            return SplitFirst( qualifiedName, separator, true );
        }

        /// <summary>
        /// 获得空白字符串数组
        /// </summary>
        /// <value>空白字符串数组</value>
        /// <remarks></remarks>
        /// <history>
        /// [zanezeng]   2008-11-18 10:01    Created
        /// </history>
        public static string[] EmptyStrings
        {
            get
            {
                return s_EmptyStrings;
            }
        }

        /// <summary>
        /// 获得空白字符数组
        /// </summary>
        /// <value>空白字符数组</value>
        /// <remarks></remarks>
        /// <history>
        /// [zanezeng]   2008-12-30 15:06    Created
        /// </history>
        public static char[] WhitespaceChars
        {
            get
            {
                return (char[])WHITESPACECHARS.Clone();
            }
        }

        /// <summary>
        /// 获得指定字符串的长度
        /// </summary>
        /// <param name="source">用于测量的源字符串</param>
        /// <returns></returns>
        /// <remarks></remarks>
        /// <history>
        /// [zanezeng]   2008-12-30 14:41    Created
        /// </history>
        public static int GetStringLenght( string source )
        {
            //判断是否为空
            if (string.IsNullOrEmpty( source ))
            {
                //如果为空，则返回0
                return 0;
            }

            //返回字符串长度
            return source.Length;
        }

        /// <summary>
        /// 判断指定的字符串是否全部由数字组成
        /// </summary>
        /// <param name="source">用于判断的源字符串</param>
        /// <returns>
        /// 	<c>true</c>：源字符串全部由数字组成<br/>
        /// 	<c>false</c>：源字符串不是全部由数字组成
        /// </returns>
        /// <remarks></remarks>
        /// <history>
        /// [FuQi]   12/8/2008 1:48 PM    Created
        /// </history>
        public static bool IsNumeric( String source )
        {
            //判断源字符串是否为空
            if (string.IsNullOrEmpty( source ))
            {
                //如果为空，则返回False
                return false;
            }

            //循环判断
            foreach (char item in source)
            {
                //判断是否为数字
                if (!char.IsNumber( item ))
                {
                    return false;
                }
            }

            //返回
            return true;
        }

        #endregion

        #region ---Contains

        /// <summary>
        /// 检查目标字符串中是否含有空白字符
        /// </summary>
        /// <param name="source">需要检查的源字符串</param>
        /// <returns>
        /// 	<c>true</c>：含有空白字符<br/>
        /// 	<c>false</c>：不含有空白字符
        /// </returns>
        /// <remarks>如果字符串为空，总是返回False</remarks>
        /// <history>
        /// [zanezeng]   2008-9-24 4:50 PM    Created
        /// </history>
        public static bool ContainsWhitespace( string source )
        {
            //判断字符串是否为空
            if (string.IsNullOrEmpty( source ))
            {
                return false;
            }

            //判断是否包含空白字符
            return -1 != IndexOfAny( source, WHITESPACECHARS );
        }

        /// <summary>
        /// 检查源字符串中是否包含候选字符数组中的任何字符
        /// </summary>
        /// <param name="source">需要检查的源字符串</param>
        /// <param name="candidate">候选字符数组</param>
        /// <returns>
        /// 	<c>true</c>：含有指定字符数组中的任何一个字符<br/>
        /// 	<c>false</c>：不含有指定字符数组中的任何一个字符
        /// </returns>
        /// <remarks>如果字符串或者字符数组为空，总是返回False</remarks>
        /// <history>
        /// [zanezeng]   2008-9-24 5:04 PM    Created
        /// </history>
        public static bool ContainsAny( string source, char[] candidate )
        {
            return ContainsAny( source, candidate, CultureInfo.CurrentCulture, CompareOptions.None );
        }

        /// <summary>
        /// 检查源字符串中是否包含候选字符数组中的任何字符
        /// </summary>
        /// <param name="source">需要检查的源字符串</param>
        /// <param name="candidate">候选字符数组</param>
        /// <param name="culture">区域信息，使用指定区域相关的字符比较规则</param>
        /// <param name="options">字符比较的选项</param>
        /// <returns>
        /// 	<c>true</c>：含有指定字符数组中的任何一个字符<br/>
        /// 	<c>false</c>：不含有指定字符数组中的任何一个字符
        /// </returns>
        /// <remarks>如果字符串或者字符数组为空，总是返回False</remarks>
        /// <history>
        /// [zanezeng]   2008-9-24 5:04 PM    Created
        /// </history>
        public static bool ContainsAny( string source, char[] candidate, CultureInfo culture, CompareOptions options )
        {
            return -1 != IndexOfAny( source, candidate, culture, options );
        }

        /// <summary>
        /// 检查源字符串中是否包含候选字符串中的任何字符
        /// </summary>
        /// <param name="source">需要检查的源字符串</param>
        /// <param name="candidate">需要检查的数组</param>
        /// <returns>
        /// 	<c>true</c>：含有指定字符串中的任何一个字符<br/>
        /// 	<c>false</c>：不含有指定字符串中的任何一个字符
        /// </returns>
        /// <remarks>如果字符串或者候选字符串为空，总是返回False</remarks>
        /// <exception cref="T:ArgumentNullException"><paramref name="candidate"/>为Null</exception>
        /// <history>
        /// [zanezeng]   2008-9-24 5:04 PM    Created
        /// </history>
        public static bool ContainsAny( string source, string candidate )
        {
            return ContainsAny( source, candidate, CultureInfo.CurrentCulture, CompareOptions.None );
        }

        /// <summary>
        /// 检查源字符串中是否包含候选字符串中的任何字符
        /// </summary>
        /// <param name="source">需要检查的源字符串</param>
        /// <param name="candidate">需要检查的数组</param>
        /// <param name="culture">区域信息，使用指定区域相关的字符比较规则</param>
        /// <param name="options">字符比较的选项</param>
        /// <returns>
        /// 	<c>true</c>：含有指定字符串中的任何一个字符<br/>
        /// 	<c>false</c>：不含有指定字符串中的任何一个字符
        /// </returns>
        /// <remarks>如果字符串或者候选字符串为空，总是返回False</remarks>
        /// <history>
        /// [zanezeng]   2008-9-24 5:04 PM    Created
        /// </history>
        public static bool ContainsAny( string source, string candidate, CultureInfo culture, CompareOptions options )
        {
            //判断是否为Null
            if (null == candidate)
            {
                //抛出异常
                throw new ArgumentNullException( "candidate" );
            }

            //判断字符串是否为空
            return -1 != IndexOfAny( source, candidate.ToCharArray(), culture, options );
        }

        #endregion

        #region ---TrimWhitespace

        /// <summary>
        /// 移除源字符串头部和尾部的空白字符
        /// </summary>
        /// <param name="source">需要处理的源字符串</param>
        /// <returns>包含处理结果的新字符串实例。如果输入的为NULL则返回空字符串</returns>
        /// <remarks></remarks>
        /// <history>
        /// [zanezeng]   2008-9-24 5:09 PM    Created
        /// </history>
        public static string TrimWhitespace( string source )
        {
            //判断字符串是否为空
            if (string.IsNullOrEmpty( source ))
            {
                //返回
                return source;
            }

            //去掉空白字符
            return source.Trim();
        }

        /// <summary>
        /// 移除源字符串中的所有空白字符
        /// </summary>
        /// <param name="source">需要处理的源字符串</param>
        /// <returns>包含处理结果的新字符串实例,如果输入的为NULL则返回空字符串</returns>
        /// <remarks></remarks>
        /// <history>
        /// [zanezeng]   2008-9-24 5:09 PM    Created
        /// </history>
        public static string TrimAllWhitespace( string source )
        {
            return TrimAll( source, WHITESPACECHARS );
        }

        /// <summary>
        /// 移除源字符串头部的空白字符
        /// </summary>
        /// <param name="source">需要处理的源字符串</param>
        /// <returns>包含处理结果的新字符串实例,如果输入的为NULL则返回空字符串</returns>
        /// <remarks>如果字符串全部由空白字符组成，则返回空字符串</remarks>
        /// <history>
        /// [zanezeng]   2008-9-24 5:09 PM    Created
        /// </history>
        public static string TrimStartsWhitespace( string source )
        {
            //判断字符串是否为空
            if (string.IsNullOrEmpty( source ))
            {
                //返回
                return source;
            }

            //去掉空白字符
            return source.TrimStart();
        }

        /// <summary>
        /// 移除指定字符串尾部的空白字符
        /// </summary>
        /// <param name="source">需要处理的源字符串</param>
        /// <returns>包含处理结果的新字符串实例,如果输入的为NULL则返回空字符串</returns>
        /// <remarks>如果字符串全部由空白字符组成，则返回空字符串</remarks>
        /// <history>
        /// [zanezeng]   2008-9-24 5:09 PM    Created
        /// </history>
        public static string TrimEndsWhitespace( string source )
        {
            //判断字符串是否为空
            if (string.IsNullOrEmpty( source ))
            {
                //返回
                return source;
            }

            //去掉空白字符
            return source.TrimEnd();
        }

        #endregion

        #region ---Trim

        /// <summary>
        /// 移除源字符串数枚举中所有字符串头部和尾部的空白字符
        /// </summary>
        /// <param name="sources">需要处理的源字符串枚举</param>
        /// <param name="removeEmpty">是否将处理结果中的Null或者空白字符串移除。如果设置为True，那么返回的结果中将不包含空字符串。</param>
        /// <returns>包含处理结果的新字符串数组实例</returns>
        /// <remarks>如果传入的数组为NULL，那么返回空数组；需要处理的源字符串数组中包含的Null会转化为空白字符串。</remarks>
        /// <history>
        /// [zanezeng]   2008-9-24 5:13 PM    Created
        /// </history>
        public static string[] Trim( ICollection<string> sources, bool removeEmpty )
        {
            return Trim( sources, WHITESPACECHARS, removeEmpty );
        }

        /// <summary>
        /// 移除源字符串数枚举中所有字符串头部和尾部的空白字符
        /// </summary>
        /// <param name="sources">需要处理的源字符串数组</param>
        /// <param name="targets">包含需要移除字符的字符数组</param>
        /// <param name="removeEmpty">是否将处理结果中的Null或者空白字符串移除。如果设置为True，那么返回的结果中将不包含空字符串。</param>
        /// <returns>包含处理结果的新字符串数组</returns>
        /// <remarks>如果传入的数组为NULL，那么返回空数组</remarks>
        /// <history>
        /// [zanezeng]   2008-9-24 5:13 PM    Created
        /// </history>
        public static string[] Trim( ICollection<string> sources, char[] targets, bool removeEmpty )
        {
            //判断是否为空
            if (CollectionUtility.IsNullOrEmpty( sources ))
            {
                return new string[0];
            }

            //用于保存结果
            List<string> result = new List<string>();

            //用于保存临时对象
            string temp = string.Empty;

            //循环处理
            foreach (string item in sources)
            {
                //Trim源字符串
                temp = Trim( item, targets );

                //判断是否移除空白
                if (!removeEmpty || !string.IsNullOrEmpty( temp ))
                {
                    //添加
                    result.Add( temp );
                }
            }

            //返回
            return result.ToArray();
        }

        /// <summary>
        /// 从源字符串的头部和尾部移除空格
        /// </summary>
        /// <param name="source">需要处理的源字符串</param>
        /// <returns>包含处理结果的新字符串数组实例</returns>
        /// <remarks>如果待处理字符串为NULL或者空字符串，则返回空字符串</remarks>
        /// <history>
        /// [zanezeng]   2008-10-13 11:19 AM    Created
        /// </history>
        public static string Trim( string source )
        {
            //判断是否空字符串
            if (string.IsNullOrEmpty( source ))
            {
                //返回空字符串
                return string.Empty;
            }

            //返回
            return source.Trim();
        }

        /// <summary>
        /// 从源字符串的头部和尾部移除目标字符
        /// </summary>
        /// <param name="source">需要处理的源字符串</param>
        /// <param name="target">需要移除的字符</param>
        /// <returns>包含处理结果的新字符串数组实例</returns>
        /// <remarks>如果待处理字符串为NULL或者空字符串，则返回空字符串</remarks>
        /// <history>
        /// [zanezeng]   2008-9-24 5:23 PM    Created
        /// </history>
        public static string Trim( string source, char target )
        {
            //判断是否空字符串
            if (string.IsNullOrEmpty( source ))
            {
                //返回空字符串
                return string.Empty;
            }

            //返回
            return source.Trim( new char[target] );
        }

        /// <summary>
        /// 从源字符串的头部和尾部移除全部的包含在目标字符串中的字符
        /// </summary>
        /// <param name="source">需要处理的源字符串</param>
        /// <param name="targets">包含需要移除字符的字符串</param>
        /// <returns>包含处理结果的新字符串实例</returns>
        /// <remarks>如果待处理字符串为NULL或者空字符串，则返回空字符串；如果包含移除字符的字符串为NULL或者为空字符串，则返回原字符串</remarks>
        /// <history>
        /// [zanezeng]   2008-9-24 5:19 PM    Created
        /// </history>
        public static string Trim( string source, string targets )
        {
            //判断Source是否为空
            if (string.IsNullOrEmpty( source ))
            {
                //直接返回
                return string.Empty;
            }

            //判断Target是否为空
            if (string.IsNullOrEmpty( targets ))
            {
                return source;
            }

            //去掉指定的字符
            source = source.Trim( targets.ToCharArray() );

            //返回
            return source;
        }

        /// <summary>
        /// 从源字符串的头部和尾部移除包含在目标字符数组中的字符
        /// </summary>
        /// <param name="source">需要处理的源字符串</param>
        /// <param name="targets">包含需要移除字符的字符数组</param>
        /// <returns>包含处理结果的新字符串实例</returns>
        /// <remarks>
        /// 	<para>如果待处理字符串为NULL或者空字符串，则返回空字符串；如果目标字符数组为NULL或者为空数组，则返回源字符串</para>
        /// 	<para>从源字符串的头部和尾部移除指定的字符集，直到遇到一个不属于目标字符串的字符为止</para>
        /// </remarks>
        /// <history>
        /// [zanezeng]   2008-9-24 5:23 PM    Created
        /// </history>
        public static string Trim( string source, char[] targets )
        {
            //判断Source是否为空
            if (string.IsNullOrEmpty( source ))
            {
                //直接返回
                return string.Empty;
            }

            //判断Target是否为空
            if (CollectionUtility.IsNullOrEmpty( targets ))
            {
                return source;
            }

            //去掉指定的字符
            source = source.Trim( targets );

            //返回
            return source;
        }

        #endregion

        #region ---TrimStart

        /// <summary>
        /// 从源字符串的头部移除目标字符
        /// </summary>
        /// <param name="source">需要处理的源字符串</param>
        /// <param name="target">需要移除的字符</param>
        /// <returns>包含处理结果的新字符串实例</returns>
        /// <remarks>
        /// 	<para>如果待处理字符串为NULL或者空字符串，则返回空字符串</para>
        /// 	<para>从源字符串的头部移除指定的字符，直到遇到一个不等于目标字符的字符为止</para>
        /// </remarks>
        /// <history>
        /// [zanezeng]   2008-9-24 5:23 PM    Created
        /// </history>
        public static string TrimStart( string source, char target )
        {
            //判断Source是否为空
            if (string.IsNullOrEmpty( source ))
            {
                //直接返回
                return string.Empty;
            }

            //去掉指定的字符
            source = source.TrimStart( new char[] { target } );

            //返回
            return source;
        }

        /// <summary>
        /// 从源字符串的头部移除包含在目标字符数组中的字符
        /// </summary>
        /// <param name="source">需要处理的源字符串</param>
        /// <param name="targets">包含需要移除字符的字符数组</param>
        /// <returns>包含处理结果的新字符串实例</returns>
        /// <remarks>
        /// 	<para>如果待处理字符串为NULL或者空字符串，则返回空字符串；如果目标字符数组为NULL或者为空数组，则返回原字符串</para>
        /// 	<para>从源字符串的头部移除指定的字符集，直到遇到一个不属于目标字符数组的字符为止</para>
        /// </remarks>
        /// <history>
        /// [zanezeng]   2008-9-24 5:23 PM    Created
        /// </history>
        public static string TrimStart( string source, char[] targets )
        {
            //判断Source是否为空
            if (string.IsNullOrEmpty( source ))
            {
                //直接返回
                return string.Empty;
            }

            //判断Target是否为空
            if (CollectionUtility.IsNullOrEmpty( targets ))
            {
                return source;
            }

            //去掉指定的字符
            source = source.TrimStart( targets );

            //返回
            return source;
        }

        /// <summary>
        /// 从源字符串的头部移除包含在目标字符串中的字符
        /// </summary>
        /// <param name="source">需要处理的源字符串</param>
        /// <param name="targets">包含需要移除字符的字符串</param>
        /// <returns>包含处理结果的新字符串实例</returns>
        /// <remarks>
        /// 	<para>如果待处理字符串为NULL或者空字符串，则返回空字符串；如果目标字符串为NULL或者为空字符串，则返回源字符串</para>
        /// 	<para>从源字符串的头部移除指定的字符集，直到遇到一个不属于目标字符串的字符为止</para>
        /// </remarks>
        /// <history>
        /// [zanezeng]   2008-9-24 5:23 PM    Created
        /// </history>
        public static string TrimStart( string source, string targets )
        {
            //判断Source是否为空
            if (string.IsNullOrEmpty( source ))
            {
                //直接返回
                return string.Empty;
            }

            //判断Target是否为空
            if (string.IsNullOrEmpty( targets ))
            {
                return source;
            }

            //去掉指定的字符
            source = source.TrimStart( targets.ToCharArray() );

            //返回
            return source;
        }

        #endregion

        #region ---TrimEnd

        /// <summary>
        /// 从源字符串的尾部移除目标字符
        /// </summary>
        /// <param name="source">需要处理的源字符串</param>
        /// <param name="target">需要移除的字符</param>
        /// <returns>包含处理结果的新字符串实例</returns>
        /// <remarks>
        /// 	<para>如果待处理字符串为NULL或者空字符串，则返回空字符串</para>
        /// 	<para>从源字符串的尾部移除指定的字符，直到遇到一个不等于目标字符的字符为止</para>
        /// </remarks>
        /// <history>
        /// [zanezeng]   2008-9-24 5:23 PM    Created
        /// </history>
        public static string TrimEnd( string source, char target )
        {
            //判断Source是否为空
            if (string.IsNullOrEmpty( source ))
            {
                //直接返回
                return string.Empty;
            }

            //去掉指定的字符
            source = source.TrimEnd( new char[] { target } );

            //返回
            return source;
        }

        /// <summary>
        /// 从源字符串的尾部移除包含在目标字符数组中的字符
        /// </summary>
        /// <param name="source">需要处理的源字符串</param>
        /// <param name="target">包含需要移除字符的字符数组</param>
        /// <returns>包含处理结果的新字符串实例</returns>
        /// <remarks>
        /// 	<para>如果待处理字符串为NULL或者空字符串，则返回空字符串；如果目标字符数组为NULL或者为空数组，则返回源字符串</para>
        /// 	<para>从源字符串的尾部移除指定的字符集，直到遇到一个不属于目标字符数组的字符为止</para>
        /// </remarks>
        /// <history>
        /// [zanezeng]   2008-9-24 5:23 PM    Created
        /// </history>
        public static string TrimEnd( string source, char[] target )
        {
            //判断Source是否为空
            if (string.IsNullOrEmpty( source ))
            {
                //直接返回
                return string.Empty;
            }

            //判断Target是否为空
            if (CollectionUtility.IsNullOrEmpty( target ))
            {
                return source;
            }

            //去掉指定的字符
            source = source.TrimEnd( target );

            //返回
            return source;
        }

        /// <summary>
        /// 从源字符串的尾部移除包含在目标字符串中的字符
        /// </summary>
        /// <param name="source">需要处理的源字符串</param>
        /// <param name="target">包含需要移除字符的字符串</param>
        /// <returns>包含处理结果的新字符串实例</returns>
        /// <remarks>
        /// 	<para>如果待处理字符串为NULL或者空字符串，则返回空字符串；如果目标字符串为NULL或者为空字符串，则返回源字符串</para>
        /// 	<para>从源字符串的尾部移除指定的字符集，直到遇到一个不属于目标字符串的字符为止</para>
        /// </remarks>
        /// <history>
        /// [zanezeng]   2008-9-24 5:23 PM    Created
        /// </history>
        public static string TrimEnd( string source, string target )
        {
            //判断Source是否为空
            if (string.IsNullOrEmpty( source ))
            {
                //直接返回
                return string.Empty;
            }

            //判断Target是否为空
            if (string.IsNullOrEmpty( target ))
            {
                return source;
            }

            //去掉指定的字符
            source = source.TrimEnd( target.ToCharArray() );

            //返回
            return source;
        }

        #endregion

        #region ---TrimAll

        /// <summary>
        /// 从源字符串中移除全部的与目标字符相同的字符
        /// </summary>
        /// <param name="source">需要处理的源字符串</param>
        /// <param name="target">需要移除的字符</param>
        /// <returns>包含处理结果的新字符串实例</returns>
        /// <remarks>如果待处理字符串为NULL或者空字符串，则返回空字符串</remarks>
        /// <history>
        /// [zanezeng]   20
        /// 08-9-24 5:23 PM    Created
        /// </history>
        public static string TrimAll( string source, char target )
        {
            return TrimAll( source, new char[] { target } );
        }

        /// <summary>
        /// 从源字符串中移除全部的包含在目标字符串中的字符
        /// </summary>
        /// <param name="source">需要处理的源字符串</param>
        /// <param name="targets">包含需要移除字符的字符串</param>
        /// <returns>包含处理结果的新字符串实例</returns>
        /// <remarks>如果待处理字符串为NULL或者空字符串，则返回空字符串；如果包含移除字符的字符串为NULL或者为空字符串，则返回原字符串</remarks>
        /// <history>
        /// [zanezeng]   2008-9-24 5:19 PM    Created
        /// </history>
        public static string TrimAll( string source, string targets )
        {
            //判断Target是否为空
            if (string.IsNullOrEmpty( targets ))
            {
                return source;
            }

            return TrimAll( source, targets.ToCharArray() );
        }

        /// <summary>
        /// 从源字符串中移除全部包含在目标字符数组中的字符
        /// </summary>
        /// <param name="source">需要处理的源字符串</param>
        /// <param name="targets">包含需要移除字符的字符数组</param>
        /// <returns>包含处理结果的新字符串实例</returns>
        /// <remarks>如果待处理字符串为NULL或者空字符串，则返回空字符串；如果目标字符数组为NULL或者为空数组，则返回源字符串</remarks>
        /// <history>
        /// [zanezeng]   2008-9-24 5:23 PM    Created
        /// </history>
        public static string TrimAll( string source, char[] targets )
        {
            //判断Source是否为空
            if (string.IsNullOrEmpty( source ))
            {
                //直接返回
                return string.Empty;
            }

            //判断Target是否为空
            if (CollectionUtility.IsNullOrEmpty( targets ))
            {
                return source;
            }

            //用于保存结果
            StringBuilder builder = new StringBuilder();

            //循环处理
            foreach (char item in source)
            {
                //判断是否为需要移除的字符
                if (-1 == Array.IndexOf<char>( targets, item ))
                {
                    //添加
                    builder.Append( item );
                }
            }

            //返回结果
            return builder.ToString();
        }

        /// <summary>
        /// 从源字符串集合中所有的字符串中移除全部包含在目标字符数组中的字符
        /// </summary>
        /// <param name="sources">需要处理的源字符串集合</param>
        /// <param name="targets">包含需要移除字符的字符数组</param>
        /// <param name="removeEmpty">是否将处理结果中的Null或者空白字符串移除。如果设置为True，那么返回的结果中将不包含空字符串。</param>
        /// <returns>包含处理结果的新字符串数组</returns>
        /// <remarks>如果传入的数组为NULL，那么返回空数组</remarks>
        /// <history>
        /// [zanezeng]   2008-11-12 14:13    Created
        /// </history>
        public static string[] TrimAll( ICollection<string> sources, char[] targets, bool removeEmpty )
        {
            //判断是否为空
            if (CollectionUtility.IsNullOrEmpty( sources ))
            {
                return new string[0];
            }

            //用于保存结果
            List<string> result = new List<string>();

            //用于保存临时对象
            string temp = string.Empty;

            //循环处理
            foreach (string item in sources)
            {
                //Trim源字符串
                temp = TrimAll( item, targets );

                //判断是否移除空白
                if (!removeEmpty || !string.IsNullOrEmpty( temp ))
                {
                    //添加
                    result.Add( temp );
                }
            }

            //返回
            return result.ToArray();
        }

        #endregion

        #region ---StartsWith

        /// <summary>
        /// 判断源字符串的开头是否与候选字符串匹配
        /// </summary>
        /// <param name="source">用来判断的源字符串</param>
        /// <param name="candidate">用来比较的候选字符串</param>
        /// <returns>
        /// 	<c>true</c>：候选字符串与源字符串开头匹配<br/>
        /// 	<c>false</c>.：候选字符串与源字符串开头不匹配
        /// </returns>
        /// <remarks>如果候选字符串为空字符串，则直接返回True。如果源字符串为Null或者为空字符串则返回False。</remarks>
        /// <history>
        /// [zanezeng]   2008-9-25 8:47 AM    Created
        /// </history>
        public static bool IsStartWith( string source, string candidate )
        {
            return IsStartWith( source, candidate, CultureInfo.CurrentCulture, CompareOptions.None );
        }

        /// <summary>
        /// 使用指定的比较选项进行比较，判断源字符串的开头是否与候选字符串匹配
        /// </summary>
        /// <param name="source">用来判断的源字符串</param>
        /// <param name="candidate">用来比较的候选字符串</param>
        /// <param name="culture">区域信息，使用指定区域相关的字符比较规则</param>
        /// <param name="options">字符比较的选项</param>
        /// <returns>
        /// 	<c>true</c>：候选字符串与源字符串开头匹配<br/>
        /// 	<c>false</c>.：候选字符串与源字符串开头不匹配
        /// </returns>
        /// <remarks></remarks>
        /// <history>
        /// [zanezeng]   2008-9-25 8:51 AM    Created
        /// </history>
        public static bool IsStartWith( string source, string candidate, CultureInfo culture, CompareOptions options )
        {
            //断言参数
            if (null == candidate)
            {
                //抛出异常
                throw new ArgumentNullException( "candidate" );
            }

            //判断源字符串是否为Null
            if (null == source)
            {
                //如果字符串为Null，则返回不包含
                return false;
            }

            //判断源字符串是否为空
            if (string.IsNullOrEmpty( source ))
            {
                //判断目标字符串是否为空
                if (string.IsNullOrEmpty( candidate ))
                {
                    //如果两个字符串都为空，则返回True
                    return true;
                }

                //如果目标字符串不为空，则返回False
                return false;
            }

            //判断区域信息是否为Null
            if (null == culture)
            {
                //如果区域信息为Null，则设置为当前默认的区域信息
                culture = CultureInfo.CurrentCulture;
            }

            //返回索引位置
            return culture.CompareInfo.IsPrefix( source, candidate, options );
        }

        #endregion

        #region ---EndsWith

        /// <summary>
        /// 判断源字符串的结尾是否与候选字符串匹配
        /// </summary>
        /// <param name="source">用来判断的源字符串</param>
        /// <param name="candidate">用来比较的候选字符串</param>
        /// <returns>
        /// 	<c>true</c>：候选字符串与源字符串结尾匹配<br/>
        /// 	<c>false</c>.：候选字符串与源字符串结尾不匹配
        /// </returns>
        /// <remarks>如果候选字符串为空字符串，则直接返回True。如果源字符串为Null或者为空字符串则返回False。</remarks>
        /// <history>
        /// [zanezeng]   2008-9-25 8:47 AM    Created
        /// </history>
        public static bool IsEndWith( string source, string candidate )
        {
            return IsEndWith( source, candidate, CultureInfo.CurrentCulture, CompareOptions.None );
        }

        /// <summary>
        /// 不依赖于区域信息进行比较，判断源字符串的结尾是否与候选字符串匹配
        /// </summary>
        /// <param name="source">用来判断的源字符串</param>
        /// <param name="candidate">用来比较的候选字符串</param>
        /// <param name="culture">区域信息，使用指定区域相关的字符比较规则</param>
        /// <param name="options">字符比较的选项</param>
        /// <returns>
        /// 	<c>true</c>：候选字符串与源字符串结尾匹配<br/>
        /// 	<c>false</c>.：候选字符串与源字符串结尾不匹配
        /// </returns>
        /// <remarks>如果候选字符串为空字符串，则直接返回True。如果源字符串为Null或者为空字符串则返回False。</remarks>
        /// <history>
        /// [zanezeng]   2008-9-25 8:47 AM    Created
        /// </history>
        public static bool IsEndWith( string source, string candidate, CultureInfo culture, CompareOptions options )
        {
            //断言参数
            if (null == candidate)
            {
                //抛出异常
                throw new ArgumentNullException( "candidate" );
            }

            //判断源字符串是否为Null
            if (null == source)
            {
                //如果字符串为Null，则返回不包含
                return false;
            }

            //判断源字符串是否为空
            if (string.IsNullOrEmpty( source ))
            {
                //判断目标字符串是否为空
                if (string.IsNullOrEmpty( candidate ))
                {
                    //如果两个字符串都为空，则返回True
                    return true;
                }

                //如果目标字符串不为空，则返回False
                return false;
            }

            //判断区域信息是否为Null
            if (null == culture)
            {
                //如果区域信息为Null，则设置为当前默认的区域信息
                culture = CultureInfo.CurrentCulture;
            }

            //返回索引位置
            return culture.CompareInfo.IsSuffix( source, candidate, options );
        }

        #endregion

        #region ---Padding

        /// <summary>
        /// 右对齐源字符串中的字符，在左边用空格填充以达到指定的总长度
        /// </summary>
        /// <param name="source">需要处理的源字符串</param>
        /// <param name="totalLength">期望的结果字符串的字符数，等于源字符串的字符数加上填充的空格数目</param>
        /// <returns>包含处理结果的新字符串实例</returns>
        /// <remarks>如果totalLength小于或者等于源字符串的长度，那么直接返回源字符串的新实例</remarks>
        /// <exception cref="T:ArgumentOutOfRangeException"><paramref name="totalLength"/>小于等于0</exception>
        /// <history>
        /// [zanezeng]   2008-9-25 9:46 AM    Created
        /// </history>
        public static string PadLeft( string source, int totalLength )
        {
            return PadLeft( source, totalLength, ' ' );
        }

        /// <summary>
        /// 右对齐源字符串中的字符，在左边用填充字符填充以达到指定的总长度
        /// </summary>
        /// <param name="source">需要处理的源字符串</param>
        /// <param name="totalLength">期望的结果字符串的字符数，等于源字符串的字符数加上填充的空格数目</param>
        /// <param name="paddingChar">用来填充的字符</param>
        /// <returns>包含处理结果的新字符串实例</returns>
        /// <remarks>如果totalLength小于或者等于源字符串的长度，那么直接返回源字符串的新实例</remarks>
        /// <history>
        /// [zanezeng]   2008-9-25 9:46 AM    Created
        /// </history>
        public static string PadLeft( string source, int totalLength, char paddingChar )
        {
            //判断参数是否越界
            if (totalLength <= 0)
            {
                //抛出异常
                throw new ArgumentOutOfRangeException( "totalLength" );
            }

            //获得安全字符串
            source = GetSafeString( source );

            //进行填补
            return source.PadLeft( totalLength, paddingChar );
        }

        /// <summary>
        /// 左对齐源字符串中的字符，在右边用空格填充以达到指定的总长度
        /// </summary>
        /// <param name="source">需要处理的源字符串</param>
        /// <param name="totalLength">期望的结果字符串的字符数，等于源字符串的字符数加上填充的空格数目</param>
        /// <returns>包含处理结果的新字符串实例</returns>
        /// <remarks>如果totalLength小于或者等于源字符串的长度，那么直接返回源字符串的新实例</remarks>
        /// <history>
        /// [zanezeng]   2008-9-25 9:46 AM    Created
        /// </history>
        public static string PadRight( string source, int totalLength )
        {
            return PadRight( source, totalLength, ' ' );
        }

        /// <summary>
        /// 左对齐源字符串中的字符，在右边用空格填充以达到指定的总长度
        /// </summary>
        /// <param name="source">需要处理的源字符串</param>
        /// <param name="totalLength">期望的结果字符串的字符数，等于源字符串的字符数加上填充的空格数目</param>
        /// <param name="paddingChar">用来填充的字符</param>
        /// <returns>包含处理结果的新字符串实例</returns>
        /// <remarks>如果totalLength小于或者等于源字符串的长度，那么直接返回源字符串的新实例</remarks>
        /// <history>
        /// [zanezeng]   2008-9-25 9:46 AM    Created
        /// </history>
        public static string PadRight( string source, int totalLength, char paddingChar )
        {
            //判断参数是否越界
            if (totalLength <= 0)
            {
                //抛出异常
                throw new ArgumentOutOfRangeException( "totalLength" );
            }

            //获得安全字符串
            source = GetSafeString( source );

            //进行填补
            return source.PadRight( totalLength, paddingChar );
        }

        #endregion

        #region ---Remove

        /// <summary>
        /// 删除源字符串中从指定位置到结尾的所有字符
        /// </summary>
        /// <param name="source">需要处理的源字符串</param>
        /// <param name="startIndex">开始删除的字符位置</param>
        /// <returns>包含处理结果的新字符串实例</returns>
        /// <exception cref="System.ArgumentOutOfRangeException">索引小于0或者索引指定的位置超出了源字符串的范围</exception>
        /// <remarks></remarks>
        /// <history>
        /// [zanezeng]   2008-9-25 10:06 AM    Created
        /// </history>
        public static string Remove( string source, int startIndex )
        {
            return Remove( source, startIndex, -1 );
        }

        /// <summary>
        /// 删除源字符串中从指定位置开始、指定数目的字符
        /// </summary>
        /// <param name="source">需要处理的源字符串</param>
        /// <param name="startIndex">开始删除的字符位置</param>
        /// <param name="count">需要删除的字符数目</param>
        /// <returns>包含处理结果的新字符串实例</returns>
        /// <exception cref="System.ArgumentOutOfRangeException">
        /// 	<list type="bullet">
        /// 		<item>
        /// 			<description>startIndex小于0</description>
        /// 		</item>
        /// 		<item>
        /// 			<description>startIndex与count之和指定的位置超出了源字符串的范围</description>
        /// 		</item>
        /// 	</list>
        /// </exception>
        /// <remarks></remarks>
        /// <history>
        /// [zanezeng]   2008-9-25 10:06 AM    Created
        /// </history>
        public static string Remove( string source, int startIndex, int count )
        {
            //断言参数
            ArgumentAssert.AssertArgumentRange( startIndex, 0, GetStringLenght( source ) - 1, "startIndex" );
            ArgumentAssert.AssertArgumentRange( count, -1, GetStringLenght( source ) - startIndex, "startIndex" );

            //判断参数
            if (string.IsNullOrEmpty( source ))
            {
                //返回空字符串
                return source;
            }

            //判断Count是否小于0
            if (count < 0)
            {
                //如果Count小于0，则设置为全部
                count = source.Length - startIndex;
            }

            //删除
            return source.Remove( startIndex, count );
        }

        #endregion

        #region ---CaseSwitch

        /// <summary>
        /// 将源字符串中的所有字符转化为大写字符
        /// </summary>
        /// <param name="source">需要处理的源字符串</param>
        /// <returns>>使用当前区域大小规则进行转化的大写副本</returns>
        /// <remarks>如果source为Null或者为空字符串总是返回空字符串</remarks>
        /// <history>
        /// [zanezeng]   2008-11-1 11:16    Created
        /// </history>
        public static string ToUpper( string source )
        {
            //判断是否为空
            if (string.IsNullOrEmpty( source ))
            {
                return string.Empty;
            }

            //转化
            return source.ToUpper();
        }

        /// <summary>
        /// 将源字符串中指定位置到结尾的字符转化为大写字符
        /// </summary>
        /// <param name="source">需要处理的源字符串</param>
        /// <param name="startIndex">开始转化的字符位置</param>
        /// <returns>使用当前区域大小规则进行转化的大写副本</returns>
        /// <remarks></remarks>
        /// <exception cref="System.ArgumentOutOfRangeException">索引小于0或者索引指定的位置超出了源字符串的范围</exception>
        /// <history>
        /// [zanezeng]   2008-9-25 10:23 AM    Created
        /// </history>
        public static string ToUpper( string source, int startIndex )
        {
            return ToUpper( source, startIndex, source.Length - startIndex );
        }

        /// <summary>
        /// 将源字符串中指定位置开始、指定数目的字符转化为大写字符
        /// </summary>
        /// <param name="source">需要处理的源字符串</param>
        /// <param name="startIndex">开始转化的字符位置</param>
        /// <param name="count">需要转化的字符数目</param>
        /// <returns>使用当前区域大小规则进行转化的大写副本</returns>
        /// <remarks></remarks>
        /// <exception cref="System.ArgumentOutOfRangeException">
        /// 	<list type="bullet">
        /// 		<item>
        /// 			<description>startIndex小于0</description>
        /// 		</item>
        /// 		<item>
        /// 			<description>count小于0</description>
        /// 		</item>
        /// 		<item>
        /// 			<description>startIndex与count之和指定的位置超出了源字符串的范围</description>
        /// 		</item>
        /// 	</list>
        /// </exception>
        /// <history>
        /// [zanezeng]   2008-9-25 10:23 AM    Created
        /// </history>
        public static string ToUpper( string source, int startIndex, int count )
        {
            return ToUpper( source, startIndex, count, CultureInfo.InvariantCulture );
        }

        /// <summary>
        /// 将源字符串中指定位置开始、指定数目的字符转化为大写字符
        /// </summary>
        /// <param name="source">需要处理的源字符串</param>
        /// <param name="startIndex">开始转化的字符位置</param>
        /// <param name="culture">区域信息，用于指定区域相关的大小写转化规则</param>
        /// <returns>使用指定区域大小规则进行转化的大写副本</returns>
        /// <remarks></remarks>
        /// <exception cref="System.ArgumentOutOfRangeException">索引小于0或者索引指定的位置超出了源字符串的范围</exception>
        /// <history>
        /// [zanezeng]   2008-9-25 10:23 AM    Created
        /// </history>
        public static string ToUpper( string source, int startIndex, CultureInfo culture )
        {
            return ToUpper( source, startIndex, source.Length - startIndex, culture );
        }

        /// <summary>
        /// 将源字符串中指定位置到结尾的字符转化为大写字符
        /// </summary>
        /// <param name="source">需要处理的源字符串</param>
        /// <param name="startIndex">开始转化的字符位置</param>
        /// <param name="count">需要转化的字符数目</param>
        /// <param name="culture">区域信息，用于指定区域相关的大小写转化规则</param>
        /// <returns>使用指定区域大小规则进行转化的大写副本</returns>
        /// <remarks></remarks>
        /// <exception cref="System.ArgumentOutOfRangeException">
        /// 	<list type="bullet">
        /// 		<item>
        /// 			<description>startIndex小于0</description>
        /// 		</item>
        /// 		<item>
        /// 			<description>count小于0</description>
        /// 		</item>
        /// 		<item>
        /// 			<description>startIndex与count之和指定的位置超出了源字符串的范围</description>
        /// 		</item>
        /// 	</list>
        /// </exception>
        /// <history>
        /// [zanezeng]   2008-9-25 10:23 AM    Created
        /// </history>
        public static string ToUpper( string source, int startIndex, int count, CultureInfo culture )
        {
            //断言参数
            ArgumentAssert.AssertArgumentRange( startIndex, 0, source.Length - 1, "startIndex" );
            ArgumentAssert.AssertArgumentRange( startIndex + count, 0, source.Length - 1, "startIndex" );
            ArgumentAssert.AssertArgumentRange( count, 0, source.Length, "count" );

            //判断是否为空字符串
            if (string.IsNullOrEmpty( source ))
            {
                //返回空字符串
                return string.Empty;
            }

            //用于保存结果
            StringBuilder builder = new StringBuilder();

            //添加字符串
            if (startIndex > 0)
            {
                builder.Append( source.Substring( 0, startIndex ) );
            }

            //添加字符串
            if (count > 0)
            {
                builder.Append( culture.TextInfo.ToUpper( source.Substring( startIndex, count ) ) );
            }

            //添加字符串
            builder.Append( source.Substring( startIndex + count ) );

            //返回
            return builder.ToString();
        }

        /// <summary>
        /// 将源字符串中的所有字符转化为小写字符
        /// </summary>
        /// <param name="source">需要处理的源字符串</param>
        /// <returns>>使用当前区域大小规则进行转化的小写副本</returns>
        /// <remarks>如果source为Null或者为空字符串总是返回空字符串</remarks>
        /// <history>
        /// [zanezeng]   2008-11-1 11:16    Created
        /// </history>
        public static string ToLower( string source )
        {
            //判断是否为空
            if (string.IsNullOrEmpty( source ))
            {
                return string.Empty;
            }

            //转化
            return source.ToLower();
        }

        /// <summary>
        /// 将源字符串中指定位置到结尾的字符转化为小写字符
        /// </summary>
        /// <param name="source">需要处理的源字符串</param>
        /// <param name="startIndex">开始转化的字符位置</param>
        /// <returns>使用当前区域大小规则进行转化的小写副本</returns>
        /// <remarks></remarks>
        /// <exception cref="System.ArgumentOutOfRangeException">索引小于0或者索引指定的位置超出了源字符串的范围</exception>
        /// <history>
        /// [zanezeng]   2008-9-25 10:23 AM    Created
        /// </history>
        public static string ToLower( string source, int startIndex )
        {
            return ToLower( source, startIndex, source.Length - startIndex, CultureInfo.InvariantCulture );
        }

        /// <summary>
        /// 将源字符串中指定位置开始、指定数目的字符转化为小写字符
        /// </summary>
        /// <param name="source">需要处理的源字符串</param>
        /// <param name="startIndex">开始转化的字符位置</param>
        /// <param name="count">需要转化的字符数目</param>
        /// <returns>使用当前区域大小规则进行转化的小写副本</returns>
        /// <remarks></remarks>
        /// <exception cref="System.ArgumentOutOfRangeException">
        /// 	<list type="bullet">
        /// 		<item>
        /// 			<description>startIndex小于0</description>
        /// 		</item>
        /// 		<item>
        /// 			<description>count小于0</description>
        /// 		</item>
        /// 		<item>
        /// 			<description>startIndex与count之和指定的位置超出了源字符串的范围</description>
        /// 		</item>
        /// 	</list>
        /// </exception>
        /// <history>
        /// [zanezeng]   2008-9-25 10:23 AM    Created
        /// </history>
        public static string ToLower( string source, int startIndex, int count )
        {
            return ToLower( source, startIndex, count, CultureInfo.InvariantCulture );
        }

        /// <summary>
        /// 将源字符串中指定位置开始、指定数目的字符转化为小写字符
        /// </summary>
        /// <param name="source">需要处理的源字符串</param>
        /// <param name="startIndex">开始转化的字符位置</param>
        /// <param name="culture">区域信息，用于指定区域相关的大小写转化规则</param>
        /// <returns>使用指定区域大小规则进行转化的小写副本</returns>
        /// <remarks></remarks>
        /// <exception cref="System.ArgumentOutOfRangeException">索引小于0或者索引指定的位置超出了源字符串的范围</exception>
        /// <history>
        /// [zanezeng]   2008-9-25 10:23 AM    Created
        /// </history>
        public static string ToLower( string source, int startIndex, CultureInfo culture )
        {
            return ToLower( source, startIndex, source.Length - startIndex, culture );
        }

        /// <summary>
        /// 将源字符串中指定位置到结尾的字符转化为小写字符
        /// </summary>
        /// <param name="source">需要处理的源字符串</param>
        /// <param name="startIndex">开始转化的字符位置</param>
        /// <param name="count">需要转化的字符数目</param>
        /// <param name="culture">区域信息，用于指定区域相关的大小写转化规则</param>
        /// <returns>使用指定区域大小规则进行转化的小写副本</returns>
        /// <remarks></remarks>
        /// <exception cref="System.ArgumentOutOfRangeException">
        /// 	<list type="bullet">
        /// 		<item>
        /// 			<description>startIndex小于0</description>
        /// 		</item>
        /// 		<item>
        /// 			<description>count小于0</description>
        /// 		</item>
        /// 		<item>
        /// 			<description>startIndex与count之和指定的位置超出了源字符串的范围</description>
        /// 		</item>
        /// 	</list>
        /// </exception>
        /// <history>
        /// [zanezeng]   2008-9-25 10:23 AM    Created
        /// </history>
        public static string ToLower( string source, int startIndex, int count, CultureInfo culture )
        {
            //断言参数
            ArgumentAssert.AssertArgumentRange( startIndex, 0, source.Length - 1, "startIndex" );
            ArgumentAssert.AssertArgumentRange( startIndex + count, 0, source.Length - 1, "startIndex" );
            ArgumentAssert.AssertArgumentRange( count, 0, source.Length, "count" );

            //判断是否为空字符串
            if (string.IsNullOrEmpty( source ))
            {
                //返回空字符串
                return string.Empty;
            }

            //用于保存结果
            StringBuilder builder = new StringBuilder();

            //添加字符串
            if (startIndex > 0)
            {
                builder.Append( source.Substring( 0, startIndex ) );
            }

            //添加字符串
            if (count > 0)
            {
                builder.Append( culture.TextInfo.ToLower( source.Substring( startIndex, count ) ) );
            }

            //添加字符串
            builder.Append( source.Substring( startIndex + count ) );

            //返回
            return builder.ToString();
        }

        #endregion

        #region ---Join

        /// <summary>
        /// 将集合中的所有对象转化为字符串并且连接成为一个完整的字符串
        /// </summary>
        /// <param name="sources">需要连接的对象集合</param>
        /// <returns>包含连接结果的字符串<br/>
        /// 如果集合为Null或者为空集合，返回空字符串</returns>
        /// <remarks>
        /// 	<example>{"A","B","C"} =&gt; ABC</example>
        /// </remarks>
        /// <history>
        /// [zanezeng]   2008-9-25 10:45 AM    Created
        /// </history>
        public static string JoinObjects( IEnumerable sources )
        {
            return JoinObjects( sources, string.Empty );
        }

        /// <summary>
        /// 将集合中的所有对象转化为字符串并且使用指定的分隔符连接成为一个完整的字符串
        /// </summary>
        /// <param name="sources">需要连接的字符串集合</param>
        /// <param name="separator">分隔字符串</param>
        /// <returns>包含连接结果的字符串<br/>
        /// 如果集合为Null或者为空集合，返回空字符串</returns>
        /// <remarks>
        /// 忽略集合中的Null或者空字符串
        /// <example>
        /// 集合：{"A","","B","C"} 分隔符：- 结果：A-B-C
        /// </example>
        /// </remarks>
        /// <history>
        /// [zanezeng]   2008-9-25 10:43 AM    Created
        /// </history>
        public static string JoinObjects( IEnumerable sources, string separator )
        {
            return JoinObjects( sources, separator, true );
        }

        /// <summary>
        /// 将集合中的所有对象转化为字符串并且使用指定的分隔符连接成为一个完整的字符串
        /// </summary>
        /// <param name="sources">需要连接的字符串集合</param>
        /// <param name="separator">分隔字符串</param>
        /// <param name="includeNull">是否包含为Null的对象。Null对象转化为空白字符串</param>
        /// <returns>包含连接结果的字符串<br/>
        /// 如果集合为Null或者为空集合，返回空字符串</returns>
        /// <remarks>
        /// 	<example>
        /// 		<list type="table">
        /// 			<item>
        /// 				<term>不包含空白（includeEmpty=True）</term>
        /// 				<term>集合：{"A","","B","C"} 分隔符：- 结果：A-B-C</term>
        /// 			</item>
        /// 			<item>
        /// 				<term>包含空白（includeEmpty=False）</term>
        /// 				<term>集合：{"A","","B","C"} 分隔符：- 结果：A--B-C</term>
        /// 			</item>
        /// 		</list>
        /// 	</example>
        /// </remarks>
        /// <history>
        /// [zanezeng]   2008-9-25 10:43 AM    Created
        /// </history>
        public static string JoinObjects( IEnumerable sources, string separator, bool includeNull )
        {
            return JoinObjects( sources, separator, includeNull, string.Empty, string.Empty );
        }

        /// <summary>
        /// 将集合中的所有对象转化为字符串并且使用指定的分隔符连接成为一个完整的字符串
        /// </summary>
        /// <param name="sources">需要连接的字符串集合</param>
        /// <param name="separator">分隔字符串</param>
        /// <param name="includeNull">是否包含为Null的对象。Null对象转化为空白字符串</param>
        /// <param name="prefix">前缀</param>
        /// <param name="suffix">后缀</param>
        /// <returns>包含连接结果的字符串<br/>
        /// 如果集合为Null或者为空集合，返回空字符串</returns>
        /// <remarks>
        /// 	<example>
        /// 		<list type="table">
        /// 			<item>
        /// 				<term>不包含空白（includeEmpty=True）</term>
        /// 				<term>集合：{"A","","B","C"} 分隔符：- 结果：A-B-C</term>
        /// 			</item>
        /// 			<item>
        /// 				<term>包含空白（includeEmpty=False）</term>
        /// 				<term>集合：{"A","","B","C"} 分隔符：- 结果：A--B-C</term>
        /// 			</item>
        /// 		</list>
        /// 	</example>
        /// </remarks>
        /// <history>
        /// [zanezeng]   2008-9-25 10:43 AM    Created
        /// </history>
        public static string JoinObjects( IEnumerable sources, string separator, bool includeNull, string prefix, string suffix )
        {
            return JoinObjects( sources, separator, includeNull, prefix, suffix, string.Empty, null );
        }

        /// <summary>
        /// 将集合中的所有对象转化为字符串并且使用指定的分隔符连接成为一个完整的字符串
        /// </summary>
        /// <param name="sources">需要连接的字符串集合</param>
        /// <param name="separator">分隔字符串</param>
        /// <param name="includeNull">是否包含为Null的对象。Null对象转化为空白字符串</param>
        /// <param name="prefix">前缀</param>
        /// <param name="suffix">后缀</param>
        /// <param name="format">用于格式化对象的格式化字符串</param>
        /// <returns>包含连接结果的字符串<br/>
        /// 如果集合为Null或者为空集合，返回空字符串</returns>
        /// <remarks>
        /// 	<example>
        /// 		<list type="table">
        /// 			<item>
        /// 				<term>不包含空白（includeEmpty=True）</term>
        /// 				<term>集合：{"A","","B","C"} 分隔符：- 结果：A-B-C</term>
        /// 			</item>
        /// 			<item>
        /// 				<term>包含空白（includeEmpty=False）</term>
        /// 				<term>集合：{"A","","B","C"} 分隔符：- 结果：A--B-C</term>
        /// 			</item>
        /// 		</list>
        /// 	</example>
        /// </remarks>
        /// <history>
        /// [zanezeng]   2008-9-25 10:43 AM    Created
        /// </history>
        public static string JoinObjects( IEnumerable sources, string separator, bool includeNull, string prefix, string suffix, string format )
        {
            return JoinObjects( sources, separator, includeNull, prefix, suffix, format, null );
        }

        /// <summary>
        /// 将集合中的所有对象转化为字符串并且使用指定的分隔符连接成为一个完整的字符串
        /// </summary>
        /// <param name="sources">需要连接的字符串集合</param>
        /// <param name="separator">分隔字符串</param>
        /// <param name="includeNull">是否包含为Null的对象。Null对象转化为空白字符串</param>
        /// <param name="prefix">前缀</param>
        /// <param name="suffix">后缀</param>
        /// <param name="format">用于格式化对象的格式化字符串</param>
        /// <param name="formatProvider">一个提供区域性特定格式设置信息的<see cref="IFormatProvider"/>对象</param>
        /// <returns>包含连接结果的字符串<br/>
        /// 如果集合为Null或者为空集合，返回空字符串</returns>
        /// <remarks>
        /// 	<example>
        /// 		<list type="table">
        /// 			<item>
        /// 				<term>不包含空白（includeEmpty=True）</term>
        /// 				<term>集合：{"A","","B","C"} 分隔符：- 结果：A-B-C</term>
        /// 			</item>
        /// 			<item>
        /// 				<term>包含空白（includeEmpty=False）</term>
        /// 				<term>集合：{"A","","B","C"} 分隔符：- 结果：A--B-C</term>
        /// 			</item>
        /// 		</list>
        /// 	</example>
        /// </remarks>
        /// <history>
        /// [zanezeng]   2008-9-25 10:43 AM    Created
        /// </history>
        public static string JoinObjects( IEnumerable sources, string separator, bool includeNull, string prefix, string suffix, string format, IFormatProvider formatProvider )
        {
            //判断集合是否为空引用
            if (null == sources)
            {
                //如果集合为空引用，则返回空字符串
                return string.Empty;
            }

            //用于保存对象格式化结果集合
            List<string> tempList = new List<string>();

            //用于保存格式化后的值
            string formattedValue = null;

            //用于保存可格式化对象
            IFormattable formattableObj = null;

            //添加到集合
            foreach (object item in sources)
            {
                //默认设置为空引用
                formattedValue = null;

                //将对象转化为可格式化对象
                formattableObj = item as IFormattable;

                //判断是否为可格式化对象
                if (null != formattableObj)
                {
                    //格式化对象
                    formattedValue = formattableObj.ToString( format, formatProvider );
                }
                //判断要格式化的对象是否不是空引用
                else if (null != item)
                {
                    //如果不是空引用，则返回对象的字符串描述
                    formattedValue = item.ToString();
                }

                //添加到格式化值列表中
                tempList.Add( formattedValue );
            }

            //返回
            return Join( tempList, separator, prefix, suffix, includeNull );
        }

        /// <summary>
        /// 连接集合中所有的字符串
        /// </summary>
        /// <param name="sources">需要连接的字符串集合</param>
        /// <returns>包含连接结果的字符串<br/>
        /// 如果集合为Null或者为空集合，返回空字符串</returns>
        /// <remarks>
        /// 	<example>{"A","B","C"} =&gt; ABC</example>
        /// </remarks>
        /// <history>
        /// [zanezeng]   2008-9-25 10:45 AM    Created
        /// </history>
        public static string Join( IEnumerable<string> sources )
        {
            return Join( sources, string.Empty );
        }

        /// <summary>
        /// 使用指定的分隔字符串连接集合中所有的字符串
        /// </summary>
        /// <param name="sources">需要连接的字符串集合</param>
        /// <param name="separator">分隔字符串</param>
        /// <returns>包含连接结果的字符串<br/>
        /// 如果集合为Null或者为空集合，返回空字符串</returns>
        /// <remarks>
        /// 忽略集合中的Null或者空字符串
        /// <example>
        /// 集合：{"A","","B","C"} 分隔符：- 结果：A-B-C
        /// </example>
        /// </remarks>
        /// <history>
        /// [zanezeng]   2008-9-25 10:43 AM    Created
        /// </history>
        public static string Join( IEnumerable<string> sources, string separator )
        {
            return Join( sources, separator, true );
        }

        /// <summary>
        /// 使用指定的分隔字符串连接集合中所有的字符串
        /// </summary>
        /// <param name="sources">需要连接的字符串集合</param>
        /// <param name="separator">分隔字符串</param>
        /// <param name="includeEmpty">是否包含空白字符串（Null等同于空字符串）。如果设置为True，那么将会包含空字符串。</param>
        /// <returns>包含连接结果的字符串<br/>
        /// 如果集合为Null或者为空集合，返回空字符串</returns>
        /// <remarks>
        /// 	<example>
        /// 		<list type="table">
        /// 			<item>
        /// 				<term>不包含空白（includeEmpty=True）</term>
        /// 				<term>集合：{"A","","B","C"} 分隔符：- 结果：A-B-C</term>
        /// 			</item>
        /// 			<item>
        /// 				<term>包含空白（includeEmpty=False）</term>
        /// 				<term>集合：{"A","","B","C"} 分隔符：- 结果：A--B-C</term>
        /// 			</item>
        /// 		</list>
        /// 	</example>
        /// </remarks>
        /// <history>
        /// [zanezeng]   2008-9-25 10:43 AM    Created
        /// </history>
        public static string Join( IEnumerable<string> sources, string separator, bool includeEmpty )
        {
            return Join( sources, separator, string.Empty, string.Empty, includeEmpty );
        }

        /// <summary>
        /// 使用指定的分隔字符串、前缀以及后缀连接集合中所有的字符串
        /// </summary>
        /// <param name="sources">需要连接的字符串集合</param>
        /// <param name="separator">分隔字符串</param>
        /// <param name="prefix">前缀</param>
        /// <param name="suffix">后缀</param>
        /// <returns>包含连接结果的字符串<br/>
        /// 如果集合为Null或者为空集合，返回空字符串</returns>
        /// <remarks>
        /// 忽略集合中的Null或者空字符串
        /// <example>集合：{"A","","B","C"} 分隔符：- 前缀：[ 后缀：] 结果：[A]-[B]-[C]</example>
        /// </remarks>
        /// <history>
        /// [zanezeng]   2008-9-25 10:49 AM    Created
        /// </history>
        public static string Join( IEnumerable<string> sources, string separator, string prefix, string suffix )
        {
            return Join( sources, separator, prefix, suffix, -1, true );
        }

        /// <summary>
        /// 使用指定的分隔字符串、前缀以及后缀连接集合中所有的字符串
        /// </summary>
        /// <param name="sources">需要连接的字符串集合</param>
        /// <param name="separator">分隔字符串</param>
        /// <param name="prefix">前缀</param>
        /// <param name="suffix">后缀</param>
        /// <param name="count">连接的个数，如果为-1，表示连接全部字符串</param>
        /// <returns>包含连接结果的字符串<br/>
        /// 如果集合为Null或者为空集合，返回空字符串</returns>
        /// <remarks>
        /// 	<para><b>注意：按照处理的字符串个数计数，其中包含NULL和空字符串</b></para>
        /// 	<para>忽略集合中的Null或者空字符串</para>
        /// 	<example>集合：{"A","","B","C"} 分隔符：- 前缀：[ 后缀：] 结果：[A]-[B]-[C]</example>
        /// </remarks>
        /// <history>
        /// [zanezeng]   2008-9-25 10:49 AM    Created
        /// </history>
        public static string Join( IEnumerable<string> sources, string separator, string prefix, string suffix, int count )
        {
            return Join( sources, separator, prefix, suffix, count, true );
        }

        /// <summary>
        /// 使用指定的分隔字符串、前缀以及后缀连接集合中所有的字符串
        /// </summary>
        /// <param name="sources">需要连接的字符串集合</param>
        /// <param name="separator">分隔字符串</param>
        /// <param name="prefix">前缀</param>
        /// <param name="suffix">后缀</param>
        /// <param name="startIndex">开始计数的字符串的位置<br/>如果开始计数位置超过了集合的范围，则返回空字符串</param>
        /// <param name="count">连接的个数\<br/>如果为-1，表示连接全部字符串<br/>最终的连接个数为count和集合的剩余长度的小值</param>
        /// <returns>包含连接结果的字符串<br/>
        /// 如果集合为Null或者为空集合，返回空字符串</returns>
        /// <remarks>
        /// 	<para><b>注意：按照处理的字符串个数计数，其中包含NULL和空字符串</b></para>
        /// 	<para>忽略集合中的Null或者空字符串</para>
        /// 	<example>集合：{"A","","B","C"} 分隔符：- 前缀：[ 后缀：] 结果：[A]-[B]-[C]</example>
        /// </remarks>
        /// <exception cref="System.ArgumentOutOfRangeException">索引小于0</exception>
        /// <history>
        /// [zanezeng]   2008-9-25 10:49 AM    Created
        /// </history>
        public static string Join( IEnumerable<string> sources, string separator, string prefix, string suffix, int startIndex, int count )
        {
            return Join( sources, separator, prefix, suffix, startIndex, count, true );
        }

        /// <summary>
        /// 使用指定的分隔字符串、前缀以及后缀连接集合中所有的字符串
        /// </summary>
        /// <param name="sources">需要连接的字符串集合</param>
        /// <param name="separator">分隔字符串</param>
        /// <param name="prefix">前缀</param>
        /// <param name="suffix">后缀</param>
        /// <param name="includeEmpty">是否包含空白字符串（Null等同于空字符串）。如果设置为True，那么将会包含空字符串。</param>
        /// <returns>包含连接结果的字符串<br/>
        /// 如果集合为Null或者为空集合，返回空字符串</returns>
        /// <remarks>
        /// 	<example>
        /// 		<list type="table">
        /// 			<item>
        /// 				<term>不包含空白（includeEmpty=True）</term>
        /// 				<term>集合：{"A","","B","C"} 分隔符：- 前缀：[ 后缀：] 结果：[A]-[B]-[C]</term>
        /// 			</item>
        /// 			<item>
        /// 				<term>包含空白（includeEmpty=False）</term>
        /// 				<term>集合：{"A","","B","C"} 分隔符：- 前缀：[ 后缀：] 结果：[A]-[]-[B]-[C]</term>
        /// 			</item>
        /// 		</list>
        /// 	</example>
        /// </remarks>
        /// <history>
        /// [zanezeng]   2008-9-25 10:49 AM    Created
        /// </history>
        public static string Join( IEnumerable<string> sources, string separator, string prefix, string suffix, bool includeEmpty )
        {
            return Join( sources, separator, prefix, suffix, 0, -1, true );
        }

        /// <summary>
        /// 使用指定的分隔字符串、前缀以及后缀连接集合中所有的字符串
        /// </summary>
        /// <param name="sources">需要连接的字符串集合</param>
        /// <param name="separator">分隔字符串</param>
        /// <param name="prefix">前缀</param>
        /// <param name="suffix">后缀</param>
        /// <param name="count">连接的个数\<br/>如果为-1，表示连接全部字符串<br/>最终的连接个数为count和集合的剩余长度的小值</param>
        /// <param name="includeEmpty">是否包含空白字符串（Null等同于空字符串）。如果设置为True，那么将会包含空字符串。</param>
        /// <returns>包含连接结果的字符串<br/>
        /// 如果集合为Null或者为空集合，返回空字符串</returns>
        /// <remarks>
        /// 	<para><b>注意：按照处理的字符串个数计数，其中包含NULL和空字符串</b></para>
        /// 	<example>
        /// 		<list type="table">
        /// 			<item>
        /// 				<term>不包含空白（includeEmpty=True）</term>
        /// 				<term>集合：{"A","","B","C"} 分隔符：- 前缀：[ 后缀：] 结果：[A]-[B]-[C]</term>
        /// 			</item>
        /// 			<item>
        /// 				<term>包含空白（includeEmpty=False）</term>
        /// 				<term>集合：{"A","","B","C"} 分隔符：- 前缀：[ 后缀：] 结果：[A]-[]-[B]-[C]</term>
        /// 			</item>
        /// 		</list>
        /// 	</example>
        /// </remarks>
        /// <history>
        /// [zanezeng]   2008-9-25 10:49 AM    Created
        /// </history>
        public static string Join( IEnumerable<string> sources, string separator, string prefix, string suffix, int count, bool includeEmpty )
        {
            return Join( sources, separator, prefix, suffix, 0, count, true );
        }

        /// <summary>
        /// 使用指定的分隔字符串、前缀以及后缀连接集合中所有的字符串
        /// </summary>
        /// <param name="sources">需要连接的字符串集合</param>
        /// <param name="separator">分隔字符串</param>
        /// <param name="prefix">前缀</param>
        /// <param name="suffix">后缀</param>
        /// <param name="startIndex">开始记录的字符串位置</param>
        /// <param name="count">连接的个数\<br/>如果为-1，表示连接全部字符串<br/>最终的连接个数为count和集合的剩余长度的小值</param>
        /// <param name="includeEmpty">是否包含空白字符串（Null等同于空字符串）。如果设置为True，那么将会包含空字符串。</param>
        /// <returns>包含连接结果的字符串<br/>
        /// 如果集合为Null或者为空集合，返回空字符串</returns>
        /// <remarks>
        /// 	<para><b>注意：按照处理的字符串个数计数，其中包含NULL和空字符串</b></para>
        /// 	<example>
        /// 		<list type="table">
        /// 			<item>
        /// 				<term>不包含空白（includeEmpty=True）</term>
        /// 				<term>集合：{"A","","B","C"} 分隔符：- 前缀：[ 后缀：] 结果：[A]-[B]-[C]</term>
        /// 			</item>
        /// 			<item>
        /// 				<term>包含空白（includeEmpty=False）</term>
        /// 				<term>集合：{"A","","B","C"} 分隔符：- 前缀：[ 后缀：] 结果：[A]-[]-[B]-[C]</term>
        /// 			</item>
        /// 		</list>
        /// 	</example>
        /// </remarks>
        /// <exception cref="System.ArgumentOutOfRangeException">
        /// <paramref name="startIndex"/>小于0或者startIndex超过<paramref name="sources"/>的范围
        /// </exception>
        /// <history>
        /// [zanezeng]   2008-9-25 10:49 AM    Created
        /// </history>
        public static string Join( IEnumerable<string> sources, string separator, string prefix, string suffix, int startIndex, int count, bool includeEmpty )
        {
            return Join( sources, separator, prefix, suffix, 0, count, true, false );
        }

        /// <summary>
        /// 使用指定的分隔字符串、前缀以及后缀连接集合中所有的字符串
        /// </summary>
        /// <param name="sources">需要连接的字符串集合</param>
        /// <param name="separator">分隔字符串</param>
        /// <param name="prefix">前缀</param>
        /// <param name="suffix">后缀</param>
        /// <param name="startIndex">开始记录的字符串位置</param>
        /// <param name="count">连接的个数\<br/>如果为-1，表示连接全部字符串<br/>最终的连接个数为count和集合的剩余长度的小值</param>
        /// <param name="includeEmpty">是否包含空白字符串（Null等同于空字符串）。如果设置为True，那么将会包含空字符串。</param>
        /// <param name="trimSource">是否对加入的数据进行Trim，默认不进行Trim</param>
        /// <returns>包含连接结果的字符串<br/>
        /// 如果集合为Null或者为空集合，返回空字符串</returns>
        /// <remarks>
        /// 	<para><b>注意：按照处理的字符串个数计数，其中包含NULL和空字符串</b></para>
        /// 	<example>
        /// 		<list type="table">
        /// 			<item>
        /// 				<term>不包含空白（includeEmpty=True）</term>
        /// 				<term>集合：{"A","","B","C"} 分隔符：- 前缀：[ 后缀：] 结果：[A]-[B]-[C]</term>
        /// 			</item>
        /// 			<item>
        /// 				<term>包含空白（includeEmpty=False）</term>
        /// 				<term>集合：{"A","","B","C"} 分隔符：- 前缀：[ 后缀：] 结果：[A]-[]-[B]-[C]</term>
        /// 			</item>
        /// 		</list>
        /// 	</example>
        /// </remarks>
        /// <exception cref="System.ArgumentOutOfRangeException">
        /// 	<paramref name="startIndex"/>小于0或者startIndex超过<paramref name="sources"/>的范围
        /// </exception>
        /// <history>
        /// [zanezeng]   2008-9-25 10:49 AM    Created
        /// </history>
        public static string Join( IEnumerable<string> sources, string separator, string prefix, string suffix, int startIndex, int count, bool includeEmpty, bool trimSource )
        {
            //判断是否为Null
            if (null == sources)
            {
                //返回空字符串
                return string.Empty;
            }

            //创建字符串构建器
            StringBuilder builder = new StringBuilder();

            //用于保存中间字符串
            string source = null;

            //用于记录是否需要添加分隔符
            bool needSeparator = false;

            //循环添加
            foreach (string item in sources)
            {
                //获得中间字符串
                source = item;

                //判断是否需要Trim
                if (trimSource)
                {
                    //去掉空格
                    source = Trim( source );
                }

                //判断是否为空
                if (includeEmpty || !string.IsNullOrEmpty( source ))
                {
                    //添加分隔符
                    if (needSeparator)
                    {
                        builder.Append( separator );
                    }

                    //添加前缀
                    builder.Append( prefix );

                    //添加字符串
                    builder.Append( source );

                    //添加后缀
                    builder.Append( suffix );

                    //设置添加分隔符
                    needSeparator = true;
                }
            }

            //返回结果
            return builder.ToString();
        }

        #endregion

        #region ---Split

        /// <summary>
        /// 按照指定的分割符将源字符串分割为字符串数组
        /// </summary>
        /// <param name="source">需要分割的源字符串</param>
        /// <param name="separators">分割符数组，遇到字符数组中包含的任何一个字符都对源字符串进行分割</param>
        /// <param name="includeEmpty">在返回的字符串数组中是否包含空字符串</param>
        /// <returns>
        /// 包含拆分结果的字符串数组
        /// <br/>如果源字符串为Null或者空，当includeEmpty为True时，返回包含一个空字符串的字符串数组；当includeEmpty为FALSE，则返回空字符串数组
        /// <br/>如果分割符数组为Null或者为空字符数组，返回包含源字符串的字符串数组
        /// </returns>
        /// <remarks></remarks>
        /// <history>
        /// [zanezeng]   2008-9-25 11:14 AM    Created
        /// </history>
        public static string[] Split( string source, char[] separators, bool includeEmpty )
        {
            //转调
            return Split( source, separators, new char[0, 2], includeEmpty, -1 );
        }

        /// <summary>
        /// 按照指定的分割符将源字符串分割为字符串数组
        /// </summary>
        /// <param name="source">需要分割的源字符串</param>
        /// <param name="separators">包含分割符的字符串，遇到字符串中包含的任何一个字符都对源字符串进行分割</param>
        /// <param name="includeEmpty">在返回的字符串数组中是否包含空字符串</param>
        /// <returns>
        /// 包含拆分结果的字符串数组
        /// <br/>如果源字符串为Null或者空，当includeEmpty为True时，返回包含一个空字符串的字符串数组；当includeEmpty为FALSE，则返回空字符串数组
        /// <br/>如果分割符数组为Null或者为空字符数组，返回包含源字符串的字符串数组
        /// </returns>
        /// <remarks></remarks>
        /// <history>
        /// [zanezeng]   2008-9-25 11:14 AM    Created
        /// </history>
        public static string[] Split( string source, string separators, bool includeEmpty )
        {
            //转调
            return Split( source, separators.ToCharArray(), new char[0, 2], includeEmpty, -1 );
        }

        /// <summary>
        /// 按照指定的分割符将源字符串分割为字符串数组
        /// </summary>
        /// <param name="source">需要分割的源字符串</param>
        /// <param name="separators">分割符数组，遇到字符数组中包含的任何一个字符都对源字符串进行分割</param>
        /// <param name="includeEmpty">在返回的字符串数组中是否包含空字符串</param>
        /// <param name="count">拆分数组的上限,如果拆分的结果超过了限定的个数,那么超过的结果将会被抛弃
        /// <br/>如果count为-1，那么表示包含所有的拆分结果</param>
        /// <returns>
        /// 包含拆分结果的字符串数组
        /// <br/>如果源字符串为Null或者空，当includeEmpty为True时，返回包含一个空字符串的字符串数组；当includeEmpty为FALSE，则返回空字符串数组
        /// <br/>如果分割符数组为Null或者为空字符数组，返回包含源字符串的字符串数组
        /// </returns>
        /// <remarks></remarks>
        /// <history>
        /// [zanezeng]   2008-9-25 11:14 AM    Created
        /// </history>
        public static string[] Split( string source, char[] separators, bool includeEmpty, int count )
        {
            //转调
            return Split( source, separators, new char[0, 2], includeEmpty, count );
        }

        /// <summary>
        /// 按照指定的分割符将源字符串分割为字符串数组
        /// </summary>
        /// <param name="source">需要分割的源字符串</param>
        /// <param name="separators">包含分割符的字符串，遇到字符串中包含的任何一个字符都对源字符串进行分割</param>
        /// <param name="includeEmpty">在返回的字符串数组中是否包含空字符串</param>
        /// <param name="count">拆分数组的上限,如果拆分的结果超过了限定的个数,那么超过的结果将会被抛弃
        /// <br/>如果count为-1，那么表示包含所有的拆分结果</param>
        /// <returns>
        /// 包含拆分结果的字符串数组
        /// <br/>如果源字符串为Null或者空，当includeEmpty为True时，返回包含一个空字符串的字符串数组；当includeEmpty为FALSE，则返回空字符串数组
        /// <br/>如果分割符数组为Null或者为空字符数组，返回包含源字符串的字符串数组
        /// </returns>
        /// <remarks></remarks>
        /// <history>
        /// [zanezeng]   2008-9-25 11:14 AM    Created
        /// </history>
        public static string[] Split( string source, string separators, bool includeEmpty, int count )
        {
            //转调
            return Split( source, separators.ToCharArray(), new char[0, 2], includeEmpty, -1 );
        }

        /// <summary>
        /// 按照指定的分割符将源字符串分割为字符串数组
        /// </summary>
        /// <param name="source">需要分割的源字符串</param>
        /// <param name="separators">分割符数组，遇到字符数组中包含的任何一个字符都对源字符串进行分割</param>
        /// <param name="includeEmpty">在返回的字符串数组中是否包含空字符串</param>
        /// <param name="trimResult">是否对拆分的结果进行Trim<br/>如果设置为True，则Trim拆分结果</param>
        /// <returns>
        /// 包含拆分结果的字符串数组
        /// <br/>如果源字符串为Null或者空，当includeEmpty为True时，返回包含一个空字符串的字符串数组；当includeEmpty为FALSE，则返回空字符串数组
        /// <br/>如果分割符数组为Null或者为空字符数组，返回包含源字符串的字符串数组
        /// </returns>
        /// <remarks></remarks>
        /// <history>
        /// [zanezeng]   2008-9-25 11:14 AM    Created
        /// </history>
        public static string[] Split( string source, char[] separators, bool includeEmpty, bool trimResult )
        {
            //转调
            return Split( source, separators, new char[0, 2], includeEmpty, -1, trimResult );
        }

        /// <summary>
        /// 按照指定的分割符将源字符串分割为字符串数组
        /// </summary>
        /// <param name="source">需要分割的源字符串</param>
        /// <param name="separators">包含分割符的字符串，遇到字符串中包含的任何一个字符都对源字符串进行分割</param>
        /// <param name="includeEmpty">在返回的字符串数组中是否包含空字符串</param>
        /// <param name="trimResult">是否对拆分的结果进行Trim<br/>如果设置为True，则Trim拆分结果</param>
        /// <returns>
        /// 包含拆分结果的字符串数组
        /// <br/>如果源字符串为Null或者空，当includeEmpty为True时，返回包含一个空字符串的字符串数组；当includeEmpty为FALSE，则返回空字符串数组
        /// <br/>如果分割符数组为Null或者为空字符数组，返回包含源字符串的字符串数组
        /// </returns>
        /// <remarks></remarks>
        /// <history>
        /// [zanezeng]   2008-9-25 11:14 AM    Created
        /// </history>
        public static string[] Split( string source, string separators, bool includeEmpty, bool trimResult )
        {
            //转调
            return Split( source, separators.ToCharArray(), new char[0, 2], includeEmpty, -1, trimResult );
        }

        /// <summary>
        /// 按照指定的分割符将源字符串分割为字符串数组
        /// </summary>
        /// <param name="source">需要分割的源字符串</param>
        /// <param name="separators">分割符数组，遇到字符数组中包含的任何一个字符都对源字符串进行分割</param>
        /// <param name="delimiters">界定符数组，包围在界定符之间的分隔符无效，数据格式：{LeftDelimiter,RightDelimiter}</param>
        /// <param name="includeEmpty">在返回的字符串数组中是否包含空字符串</param>
        /// <returns>
        /// 包含拆分结果的字符串数组
        /// <br/>如果源字符串为Null或者空，当includeEmpty为True时，返回包含一个空字符串的字符串数组；当includeEmpty为FALSE，则返回空字符串数组
        /// <br/>如果分割符数组为Null或者为空字符数组，返回包含源字符串的字符串数组
        /// </returns>
        /// <remarks>
        /// 	<example>源字符串：A,A[,]BBB 分割符：{,} 限定符：{[,]} 分割结果：{"A","A[,]BBB"} 说明：在界定符之间的分割符失效</example>
        /// </remarks>
        /// <history>
        /// [zanezeng]   2008-9-25 11:14 AM    Created
        /// </history>
        public static string[] Split( string source, char[] separators, char[] delimiters, bool includeEmpty )
        {
            //转调
            return Split( source, separators, delimiters, includeEmpty, -1 );
        }

        /// <summary>
        /// 按照指定的分割符将源字符串分割为字符串数组
        /// </summary>
        /// <param name="source">需要分割的源字符串</param>
        /// <param name="separators">分割符数组，遇到字符数组中包含的任何一个字符都对源字符串进行分割</param>
        /// <param name="delimiters">界定符数组，包围在界定符之间的分隔符无效，数据格式：{LeftDelimiter,RightDelimiter}</param>
        /// <param name="includeEmpty">在返回的字符串数组中是否包含空字符串</param>
        /// <param name="count">拆分数组的上限,如果拆分的结果超过了限定的个数,那么超过的结果将会被抛弃
        /// <br/>如果count为-1，那么表示包含所有的拆分结果</param>
        /// <returns>
        /// 包含拆分结果的字符串数组
        /// <br/>如果源字符串为Null或者空，当includeEmpty为True时，返回包含一个空字符串的字符串数组；当includeEmpty为FALSE，则返回空字符串数组
        /// <br/>如果分割符数组为Null或者为空字符数组，返回包含源字符串的字符串数组
        /// </returns>
        /// <exception cref="System.ArgumentException"><paramref name="delimiters"/>不合法的界定符</exception>
        /// <remarks>
        /// 	<example>源字符串：A,A[,]BBB 分割符：{,} 限定符：{[,]} 分割结果：{"A","A[,]BBB"} 说明：在界定符之间的分割符失效</example>
        /// </remarks>
        /// <history>
        /// [zanezeng]   2008-9-25 11:14 AM    Created
        /// </history>
        public static string[] Split( string source, char[] separators, char[] delimiters, bool includeEmpty, int count )
        {
            //界定符数组
            char[,] tempDelimiters = null;

            //判断界定符号是否有效
            if (!CollectionUtility.IsNullOrEmpty( delimiters ))
            {
                //判断长度是否为2
                if (delimiters.Length != 2)
                {
                    throw new ArgumentException( "Illegal delimiters. Regular delimiters format is {LeftDelimiter,RightDelimiter}", "delimiters" );
                }

                //创建数组
                tempDelimiters = new char[1, 2];

                //赋值
                tempDelimiters[0, 0] = delimiters[0];
                tempDelimiters[0, 1] = delimiters[1];
            }

            //转调
            return Split( source, separators, tempDelimiters, includeEmpty, count, false );
        }

        /// <summary>
        /// 按照指定的分割符将源字符串分割为字符串数组
        /// </summary>
        /// <param name="source">需要分割的源字符串</param>
        /// <param name="separators">分割符数组，遇到字符数组中包含的任何一个字符都对源字符串进行分割</param>
        /// <param name="delimiters">成对的界定符数组，包围在界定符之间的分隔符无效
        /// <br/>成对界定符数组的格式为{{LeftDelimiter,RightDelimiter},{LeftDelimiter,RightDelimiter}}，其中左右界定符必须成对出现，成对出现的界定符之间的分割符无效</param>
        /// <param name="includeEmpty">在返回的字符串数组中是否包含空字符串</param>
        /// <returns>
        /// 包含拆分结果的字符串数组
        /// <br/>如果源字符串为Null或者空，当includeEmpty为True时，返回包含一个空字符串的字符串数组；当includeEmpty为FALSE，则返回空字符串数组
        /// <br/>如果分割符数组为Null或者为空字符数组，返回包含源字符串的字符串数组
        /// </returns>
        /// <remarks>
        /// 	<para><b>注意：左右界定符号不能重复，例如[和]组成一对界定符，那么在其它的界定符号中都不允许出现符号[和]</b></para>
        /// 	<example>源字符串：A,A[,]BBB 分割符：{,} 限定符：{[,]} 分割结果：{"A","A[,]BBB"} 说明：在界定符之间的分割符失效</example>
        /// </remarks>
        /// <history>
        /// [zanezeng]   2008-9-25 11:14 AM    Created
        /// </history>
        public static string[] Split( string source, char[] separators, char[,] delimiters, bool includeEmpty )
        {
            //转调
            return Split( source, separators, delimiters, includeEmpty, -1 );
        }

        /// <summary>
        /// 按照指定的分割符将源字符串分割为字符串数组
        /// </summary>
        /// <param name="source">需要分割的源字符串</param>
        /// <param name="separators">分割符数组，遇到字符数组中包含的任何一个字符都对源字符串进行分割</param>
        /// <param name="delimiters">成对的界定符数组，包围在界定符之间的分隔符无效
        /// <br/>成对界定符数组的格式为{{LeftDelimiter,RightDelimiter},{LeftDelimiter,RightDelimiter}}，其中左右界定符必须成对出现，成对出现的界定符之间的分割符无效</param>
        /// <param name="includeEmpty">在返回的字符串数组中是否包含空字符串</param>
        /// <param name="count">拆分数组的上限,如果拆分的结果超过了限定的个数,那么超过的结果将会被抛弃
        /// <br/>如果count为-1，那么表示包含所有的拆分结果</param>
        /// <returns>
        /// 包含拆分结果的字符串数组
        /// <br/>如果源字符串为Null或者空，当includeEmpty为True时，返回包含一个空字符串的字符串数组；当includeEmpty为FALSE，则返回空字符串数组
        /// <br/>如果分割符数组为Null或者为空字符数组，返回包含源字符串的字符串数组
        /// </returns>
        /// <exception cref="System.ArgumentNullException"><paramref name="separators"/>为Null或者为空数组</exception>
        /// <exception cref="System.ArgumentException"><paramref name="delimiters"/>不合法的界定符</exception>
        /// <exception cref="System.ArgumentOutOfRangeException"><paramref name="count"/>小于等于0</exception>
        /// <remarks>
        /// 	<para><b>注意：左右界定符号不能重复，例如[和]组成一对界定符，那么在其它的界定符号中都不允许出现符号[和]</b></para>
        /// 	<example>源字符串：A,A[,]BBB 分割符：{,} 限定符：{[,]} 分割结果：{"A","A[,]BBB"} 说明：在界定符之间的分割符失效</example>
        /// </remarks>
        /// <history>
        /// [zanezeng]   2008-9-25 11:14 AM    Created
        /// </history>
        public static string[] Split( string source, char[] separators, char[,] delimiters, bool includeEmpty, int count )
        {
            //转调
            return Split( source, separators, delimiters, includeEmpty, count, false );
        }

        /// <summary>
        /// 按照指定的分割符将源字符串分割为字符串数组
        /// </summary>
        /// <param name="source">需要分割的源字符串</param>
        /// <param name="separators">分割符数组，遇到字符数组中包含的任何一个字符都对源字符串进行分割</param>
        /// <param name="delimiters">成对的界定符数组，包围在界定符之间的分隔符无效
        /// <br/>成对界定符数组的格式为{{LeftDelimiter,RightDelimiter},{LeftDelimiter,RightDelimiter}}，其中左右界定符必须成对出现，成对出现的界定符之间的分割符无效</param>
        /// <param name="includeEmpty">在返回的字符串数组中是否包含空字符串</param>
        /// <param name="count">拆分数组的上限,如果拆分的结果超过了限定的个数,那么超过的结果将会被抛弃
        /// <br/>如果count为-1，那么表示包含所有的拆分结果</param>
        /// <param name="trimResult">是否对拆分的结果进行Trim<br/>如果设置为True，则Trim拆分结果</param>
        /// <returns>
        /// 包含拆分结果的字符串数组
        /// <br/>如果源字符串为Null或者空，当includeEmpty为True时，返回包含一个空字符串的字符串数组；当includeEmpty为FALSE，则返回空字符串数组
        /// <br/>如果分割符数组为Null或者为空字符数组，返回包含源字符串的字符串数组
        /// </returns>
        /// <exception cref="System.ArgumentException"><paramref name="source"/>不合法的字符串</exception>
        /// <exception cref="System.ArgumentNullException"><paramref name="separators"/>为Null或者为空数组</exception>
        /// <exception cref="System.ArgumentException"><paramref name="delimiters"/>不合法的界定符</exception>
        /// <exception cref="System.ArgumentOutOfRangeException"><paramref name="count"/>等于0</exception>
        /// <remarks>
        /// 	<para><b>注意：左右界定符号不能重复，例如[和]组成一对界定符，那么在其它的界定符号中都不允许出现符号[和]</b></para>
        /// 	<example>源字符串：A,A[,]BBB 分割符：{,} 限定符：{[,]} 分割结果：{"A","A[,]BBB"} 说明：在界定符之间的分割符失效</example>
        /// </remarks>
        /// <history>
        /// [zanezeng]   2008-9-25 11:14 AM    Created
        /// </history>
        public static string[] Split( string source, char[] separators, char[,] delimiters, bool includeEmpty, int count, bool trimResult )
        {
            //断言参数
            ArgumentAssert.AssertArgumentRange( count, -1, int.MaxValue, "count" );
            ArgumentAssert.AssertCollectionArgumentNotNullOrEmpty<char>( separators, "separators" );

            //判断是否为空
            if (!HasText( source ))
            {
                return new string[0];
            }

            //用于保存临时字符串
            string temp = null;

            //用于保存结果
            List<string> tempList = new List<string>();

            //判断是否存在限定符号
            if (null == delimiters || 0 == delimiters.Length)
            {
                //直接拆分
                string[] result = source.Split( separators );

                //获得循环次数
                count = (-1 == count) ? result.Length : Math.Min( count, result.Length );

                //循环添加
                for (int index = 0; index < count; index++)
                {
                    //获得临时字符串
                    temp = StringUtility.GetSafeString( result[index] );

                    //Trim结果
                    if (trimResult)
                    {
                        temp = temp.Trim();
                    }

                    //判断是否包含空白
                    if (includeEmpty || !StringUtility.IsNullOrEmpty( temp ))
                    {
                        //添加
                        tempList.Add( temp );
                    }
                }

                //返回
                return tempList.ToArray();
            }

            //断言界定符
            if (delimiters.Rank != 2)
            {
                throw new ArgumentException( Resources.MSG_DELIMITER_FORMAT_INVALID, "delimiters" );
            }

            //用于保存界定符字符
            Dictionary<char, char> delimiterMap = new Dictionary<char, char>();

            //循环添加
            for (int index = 0; index < delimiters.GetLength( 0 ); index++)
            {
                //判断限定符是否包含在分隔符中
                if (-1 != Array.IndexOf<char>( separators, delimiters[index, 0] ))
                {
                    //抛出异常
                    throw new ArgumentException( string.Format( Resources.MSG_DELIMITER_DUPLICATEWITHSEPARATOR, delimiters[index, 0] ), "delimiters" );
                }

                if (-1 != Array.IndexOf<char>( separators, delimiters[index, 1] ))
                {
                    //抛出异常
                    throw new ArgumentException( string.Format( Resources.MSG_DELIMITER_DUPLICATEWITHSEPARATOR, delimiters[index, 1] ), "delimiters" );
                }

                //判断是左界定符是否已经存在
                if (delimiterMap.ContainsKey( delimiters[index, 0] ))
                {
                    //抛出异常
                    throw new ArgumentException( string.Format( Resources.MSG_DELIMITER_DUPLICATE, delimiters[index, 0] ), "delimiters" );
                }

                //判断右界定符是否已经存在
                if (delimiterMap.ContainsKey( delimiters[index, 1] ) || delimiterMap.ContainsValue( delimiters[index, 1] ))
                {
                    //抛出异常
                    throw new ArgumentException( string.Format( Resources.MSG_DELIMITER_DUPLICATE, delimiters[index, 1] ), "delimiters" );
                }

                //添加
                delimiterMap.Add( delimiters[index, 0], delimiters[index, 1] );
            }

            //用于创建字符串
            StringBuilder builder = new StringBuilder();

            //用于记录已经处理的数目
            int includeCount = 0;

            //左侧界定符
            char? leftDelimiter = null;

            //右侧的界定符
            char? rightDelimiter = null;

            //循环处理字符串
            foreach (char item in source)
            {
                //判断是否处于界定符中
                if (null != leftDelimiter)
                {
                    //如果处在界定符中，需要判断当前字符是否为右界定符
                    if (rightDelimiter.Value == item)
                    {
                        //清除左侧界定符
                        leftDelimiter = null;

                        //清除右侧界定符
                        rightDelimiter = null;
                    }
                    else
                    {
                        //添加字符
                        builder.Append( item );
                    }
                }
                else
                {
                    //判断是否为左界定符
                    if (delimiterMap.ContainsKey( item ))
                    {
                        //设置左界定符
                        leftDelimiter = item;

                        //设置右界定符
                        rightDelimiter = delimiterMap[item];
                    }
                    else if (separators.Contains( item ))
                    {
                        //判断是否为分隔符，如果是分隔符那么添加字符串
                        temp = builder.ToString();

                        //清除StringBuilder
                        builder.Remove( 0, builder.Length );

                        //Trim结果
                        if (trimResult)
                        {
                            temp = temp.Trim();
                        }

                        //判断是否包含空白
                        if (includeEmpty || !StringUtility.IsNullOrEmpty( temp ))
                        {
                            //添加
                            tempList.Add( temp );

                            //增加计数
                            includeCount += 1;

                            //判断是否到达预定的数目
                            if (includeCount == count)
                            {
                                //如果到达，则终止处理
                                return tempList.ToArray();
                            }
                        }
                    }
                    else
                    {
                        //添加字符
                        builder.Append( item );
                    }
                }
            }

            //判断是否有悬挂的界定符
            if (null != leftDelimiter)
            {
                //抛出异常
                throw new ArgumentException( "Illegal source string. Delimiter not pairs", "source" );
            }

            //获得最后剩下的字符
            temp = builder.ToString();

            //清除StringBuilder
            builder.Remove( 0, builder.Length );

            //Trim结果
            if (trimResult)
            {
                temp = temp.Trim();
            }

            //判断是否包含空白
            if (includeEmpty || !StringUtility.IsNullOrEmpty( temp ))
            {
                //添加
                tempList.Add( temp );
            }

            //返回
            return tempList.ToArray();
        }

        /// <summary>
        /// 从源字符串第一个出现的拆分符字符的位置开始拆分，将拆分的结果保存为名值对
        /// </summary>
        /// <param name="source">需要进行拆分的</param>
        /// <param name="separator">分割符</param>
        /// <param name="trimResult">是否对拆分的结果进行Trim<br/>如果设置为True，则Trim拆分结果</param>
        /// <returns>
        /// 包含拆分结果的字符串数组
        /// <br/>结果的格式为{"Key","Value"}
        /// <br/>如果源字符串为Null或者为空字符串，那么返回包含两个空字符串的字符串数组
        /// <br/>如果在源字符串中不包含分割符，那么将源字符串的副本作为Key在结果中返回
        /// </returns>
        /// <remarks>
        /// 	<example>Key=Value =&gt; {"Key","Value"}</example>
        /// </remarks>
        /// <history>
        /// [zanezeng]   2008-9-25 11:46 AM    Created
        /// </history>
        public static string[] SplitFirst( string source, char separator, bool trimResult )
        {
            //判断输入的字符串是否为空
            if (string.IsNullOrEmpty( source ))
            {
                //返回空字符串数组
                return new string[] { string.Empty, string.Empty };
            }

            //获得分隔符的位置
            int index = source.IndexOf( separator );

            //判断是否存在
            if (-1 == index)
            {
                //判断是否需要Trim
                if (trimResult)
                {
                    source = source.Trim();
                }

                //返回
                return new string[] { source, string.Empty };
            }
            else
            {
                //分解
                string leftPart = source.Substring( 0, index );
                string rightPart = source.Substring( index + 1 );

                //判断是否需要Trim
                if (trimResult)
                {
                    leftPart = leftPart.Trim();
                    rightPart = rightPart.Trim();
                }

                //返回
                return new string[] { leftPart, rightPart };
            }
        }

        /// <summary>
        /// 从源字符串最后一个出现的拆分符字符的位置开始拆分，将拆分的结果保存为名值对
        /// </summary>
        /// <param name="source">需要进行拆分的</param>
        /// <param name="separator">分割符</param>
        /// <param name="trimResult">是否对拆分的结果进行Trim<br/>如果设置为True，则Trim拆分结果</param>
        /// <returns>
        /// 包含拆分结果的字符串数组
        /// <br/>结果的格式为{"Key","Value"}
        /// <br/>如果源字符串为Null或者为空字符串，那么返回包含两个空字符串的字符串数组
        /// <br/>如果在源字符串中不包含分割符，那么将源字符串的副本作为Key在结果中返回
        /// </returns>
        /// <remarks>
        /// 	<example>Key=Value =&gt; {"Key","Value"}</example>
        /// </remarks>
        /// <history>
        /// [zanezeng]   2008-9-25 11:46 AM    Created
        /// </history>
        public static string[] SplitLast( string source, char separator, bool trimResult )
        {
            //判断输入的字符串是否为空
            if (string.IsNullOrEmpty( source ))
            {
                //返回空字符串数组
                return new string[] { string.Empty, string.Empty };
            }

            //获得分隔符的位置
            int index = source.LastIndexOf( separator );

            //判断是否存在
            if (-1 == index)
            {
                //判断是否需要Trim
                if (trimResult)
                {
                    source = source.Trim();
                }

                //返回
                return new string[] { source, string.Empty };
            }
            else
            {
                //分解
                string leftPart = source.Substring( 0, index );
                string rightPart = source.Substring( index + 1 );

                //判断是否需要Trim
                if (trimResult)
                {
                    leftPart = leftPart.Trim();
                    rightPart = rightPart.Trim();
                }

                //返回
                return new string[] { leftPart, rightPart };
            }
        }

        #endregion

        #region ---IndexOf

        /// <summary>
        /// 获得目标字符在源字符串中的第一个匹配项的索引位置
        /// </summary>
        /// <param name="source">用于检索的源字符串</param>
        /// <param name="target">要查找的字符</param>
        /// <returns>
        /// 如果找到该字符，则为目标字符的索引位置；否则如果未找到，则为 -1；如果source为Null或者空字符串，则为-1
        /// </returns>
        /// <remarks>索引从0开始<br/>区分大小写<br/>不区分区域
        /// </remarks>
        /// <history>
        /// [zanezeng]   2008-9-25 1:05 PM    Created
        /// </history>
        public static int IndexOf( string source, char target )
        {
            return IndexOf( source, target, 0, GetStringLenght( source ), CultureInfo.CurrentCulture, CompareOptions.None );
        }

        /// <summary>
        /// 获得目标字符在源字符串中的第一个匹配项的索引位置
        /// </summary>
        /// <param name="source">用于检索的源字符串</param>
        /// <param name="target">要查找的字符</param>
        /// <param name="culture">区域信息，使用指定区域相关的字符比较规则</param>
        /// <param name="options">字符比较的选项</param>
        /// <returns>
        /// 如果找到该字符，则为目标字符的索引位置；否则如果未找到，则为 -1；如果source为Null或者空字符串，则为-1
        /// </returns>
        /// <remarks>索引从0开始
        /// </remarks>
        /// <history>
        /// [zanezeng]   2008-9-25 1:05 PM    Created
        /// </history>
        public static int IndexOf( string source, char target, CultureInfo culture, CompareOptions options )
        {
            return IndexOf( source, target, 0, GetStringLenght( source ), culture, options );
        }

        /// <summary>
        /// 搜索指定的字符，并返回源字符串内从指定的索引位置到字符串结尾这一部分中第一个匹配项的从零开始的索引
        /// </summary>
        /// <param name="source">用于检索的源字符串</param>
        /// <param name="target">要查找的字符</param>
        /// <param name="startIndex">从零开始的搜索的起始索引</param>
        /// <returns>
        /// 如果找到该字符，则为目标字符的索引位置；否则如果未找到，则为 -1；如果source为Null或者空字符串，则为-1
        /// </returns>
        /// <exception cref="System.ArgumentOutOfRangeException">startIndex小于0或者startIndex 超出了 source 的有效索引范围</exception>
        /// <remarks>索引从0开始<br/>区分大小写<br/>不区分区域
        /// </remarks>
        /// <history>
        /// [zanezeng]   2008-9-25 1:05 PM    Created
        /// </history>
        public static int IndexOf( string source, char target, int startIndex )
        {
            return IndexOf( source, target, startIndex, GetStringLenght( source ) - startIndex, CultureInfo.CurrentCulture, CompareOptions.None );
        }

        /// <summary>
        /// 搜索指定的字符，并返回源字符串内从指定的索引位置到字符串结尾这一部分中第一个匹配项的从零开始的索引
        /// </summary>
        /// <param name="source">用于检索的源字符串</param>
        /// <param name="target">要查找的字符</param>
        /// <param name="startIndex">从零开始的搜索的起始索引</param>
        /// <param name="culture">区域信息，使用指定区域相关的字符比较规则</param>
        /// <param name="options">字符比较的选项</param>
        /// <returns>
        /// 如果找到该字符，则为目标字符的索引位置；否则如果未找到，则为 -1；如果source为Null或者空字符串，则为-1
        /// </returns>
        /// <remarks>索引从0开始
        /// </remarks>
        /// <exception cref="System.ArgumentOutOfRangeException">startIndex小于0或者startIndex 超出了 source 的有效索引范围</exception>
        /// <history>
        /// [zanezeng]   2008-9-25 1:05 PM    Created
        /// </history>
        public static int IndexOf( string source, char target, int startIndex, CultureInfo culture, CompareOptions options )
        {
            return IndexOf( source, target, startIndex, GetStringLenght( source ) - startIndex, culture, options );
        }

        /// <summary>
        /// 搜索指定的字符，并返回源字符串内从指定的索引位置起指定数目个字符范围内这一部分中第一个匹配项的从零开始的索引
        /// </summary>
        /// <param name="source">用于检索的源字符串</param>
        /// <param name="target">要查找的字符</param>
        /// <param name="startIndex">从零开始的搜索的起始索引</param>
        /// <param name="count">从指定位置开始的字符个数</param>
        /// <returns>
        /// 如果找到该字符，则为目标字符的索引位置；否则如果未找到，则为 -1；如果source为Null或者空字符串，则为-1
        /// </returns>
        /// <exception cref="System.ArgumentOutOfRangeException">startIndex小于0或者startIndex 超出了 source 的有效索引范围；count小于0；startIndex加上count超过源字符串范围</exception>
        /// <remarks>索引从0开始<br/>区分大小写<br/>不区分区域
        /// </remarks>
        /// <history>
        /// [zanezeng]   2008-9-25 1:05 PM    Created
        /// </history>
        public static int IndexOf( string source, char target, int startIndex, int count )
        {
            return IndexOf( source, target, startIndex, count, CultureInfo.CurrentCulture, CompareOptions.None );
        }

        /// <summary>
        /// 搜索指定的字符，并返回源字符串内从指定的索引位置起指定数目个字符范围内这一部分中第一个匹配项的从零开始的索引
        /// </summary>
        /// <param name="source">用于检索的源字符串</param>
        /// <param name="target">要查找的字符</param>
        /// <param name="startIndex">从零开始的搜索的起始索引</param>
        /// <param name="count">从指定位置开始的字符个数</param>
        /// <param name="culture">区域信息，使用指定区域相关的字符比较规则</param>
        /// <param name="options">字符比较的选项</param>
        /// <returns>
        /// 如果找到该字符，则为目标字符的索引位置；否则如果未找到，则为 -1；如果source为Null或者空字符串，则为-1
        /// </returns>
        /// <remarks>索引从0开始
        /// </remarks>
        /// <exception cref="System.ArgumentOutOfRangeException">startIndex小于0或者startIndex 超出了 source 的有效索引范围；count小于0；startIndex加上count超过源字符串范围</exception>
        /// <history>
        /// [zanezeng]   2008-9-25 1:05 PM    Created
        /// </history>
        public static int IndexOf( string source, char target, int startIndex, int count, CultureInfo culture, CompareOptions options )
        {
            //判断字符串是否为空
            if (string.IsNullOrEmpty( source ))
            {
                //如果字符串为空，则返回-1
                return -1;
            }

            //断言参数
            ArgumentAssert.AssertArgumentRange( startIndex, 0, source.Length - 1, "startIndex" );
            ArgumentAssert.AssertArgumentRange( count, 0, source.Length, "count" );
            ArgumentAssert.AssertArgumentRange( startIndex + count - 1, 0, source.Length - 1, "count" );

            //判断区域信息是否为Null
            if (null == culture)
            {
                //如果区域信息为Null，则设置为当前默认的区域信息
                culture = CultureInfo.CurrentCulture;
            }

            //返回索引位置
            return culture.CompareInfo.IndexOf( source, target, startIndex, count, options );
        }

        /// <summary>
        /// 获得目标字符串在源字符串中的第一个匹配项的索引位置
        /// </summary>
        /// <param name="source">用于检索的源字符串</param>
        /// <param name="target">要查找的字符串</param>
        /// <returns>
        /// 如果找到该字符，则为目标字符串的索引位置；否则如果未找到，则为 -1；如果source为Null或者空字符串，则为-1
        /// </returns>
        /// <remarks>索引从0开始<br/>区分大小写<br/>不区分区域
        /// </remarks>
        /// <exception cref="System.ArgumentNullException">target为Null或者为空字符串</exception>
        /// <history>
        /// [zanezeng]   2008-9-25 1:05 PM    Created
        /// </history>
        public static int IndexOf( string source, string target )
        {
            return IndexOf( source, target, 0, GetStringLenght( source ), CultureInfo.CurrentCulture, CompareOptions.None );
        }

        /// <summary>
        /// 获得目标字符串在源字符串中的第一个匹配项的索引位置
        /// </summary>
        /// <param name="source">用于检索的源字符串</param>
        /// <param name="target">要查找的字符串</param>
        /// <param name="culture">区域信息，使用指定区域相关的字符比较规则</param>
        /// <param name="options">字符比较的选项</param>
        /// <returns>
        /// 如果找到该字符，则为目标字符串的索引位置；否则如果未找到，则为 -1；如果source为Null或者空字符串，则为-1
        /// </returns>
        /// <remarks>索引从0开始
        /// </remarks>
        /// <exception cref="System.ArgumentNullException">target为Null或者为空字符串</exception>
        /// <history>
        /// [zanezeng]   2008-9-25 1:05 PM    Created
        /// </history>
        public static int IndexOf( string source, string target, CultureInfo culture, CompareOptions options )
        {
            return IndexOf( source, target, 0, GetStringLenght( source ), culture, options );
        }

        /// <summary>
        /// 搜索指定的字符串，并返回源字符串内从指定的索引位置到字符串结尾这一部分中第一个匹配项的从零开始的索引
        /// </summary>
        /// <param name="source">用于检索的源字符串</param>
        /// <param name="target">要查找的字符串</param>
        /// <param name="startIndex">从零开始的搜索的起始索引</param>
        /// <returns>
        /// 如果找到该字符，则为目标字符串的索引位置；否则如果未找到，则为 -1；如果source为Null或者空字符串，则为-1
        /// </returns>
        /// <exception cref="System.ArgumentOutOfRangeException">startIndex小于0或者startIndex 超出了 source 的有效索引范围</exception>
        /// <exception cref="System.ArgumentNullException">target为Null或者为空字符串</exception>
        /// <remarks>索引从0开始<br/>区分大小写<br/>不区分区域
        /// </remarks>
        /// <history>
        /// [zanezeng]   2008-9-25 1:05 PM    Created
        /// </history>
        public static int IndexOf( string source, string target, int startIndex )
        {
            return IndexOf( source, target, startIndex, GetStringLenght( source ) - startIndex, CultureInfo.CurrentCulture, CompareOptions.None );
        }

        /// <summary>
        /// 搜索指定的字符串，并返回源字符串内从指定的索引位置到字符串结尾这一部分中第一个匹配项的从零开始的索引
        /// </summary>
        /// <param name="source">用于检索的源字符串</param>
        /// <param name="target">要查找的字符串</param>
        /// <param name="startIndex">从零开始的搜索的起始索引</param>
        /// <param name="culture">区域信息，使用指定区域相关的字符比较规则</param>
        /// <param name="options">字符比较的选项</param>
        /// <returns>
        /// 如果找到该字符，则为目标字符串的索引位置；否则如果未找到，则为 -1；如果source为Null或者空字符串，则为-1
        /// </returns>
        /// <remarks>索引从0开始
        /// </remarks>
        /// <exception cref="System.ArgumentOutOfRangeException">startIndex小于0或者startIndex 超出了 source 的有效索引范围</exception>
        /// <exception cref="System.ArgumentNullException">target为Null或者为空字符串</exception>
        /// <history>
        /// [zanezeng]   2008-9-25 1:05 PM    Created
        /// </history>
        public static int IndexOf( string source, string target, int startIndex, CultureInfo culture, CompareOptions options )
        {
            return IndexOf( source, target, startIndex, GetStringLenght( source ) - startIndex, culture, options );
        }

        /// <summary>
        /// 搜索指定的字符串，并返回源字符串内从指定的索引位置起指定数目个字符范围内这一部分中第一个匹配项的从零开始的索引
        /// </summary>
        /// <param name="source">用于检索的源字符串</param>
        /// <param name="target">要查找的字符串</param>
        /// <param name="startIndex">从零开始的搜索的起始索引</param>
        /// <param name="count">从指定位置开始的字符个数</param>
        /// <returns>
        /// 如果找到该字符，则为目标字符串的索引位置；否则如果未找到，则为 -1；如果source为Null或者空字符串，则为-1
        /// </returns>
        /// <exception cref="System.ArgumentOutOfRangeException">startIndex小于0或者startIndex 超出了 source 的有效索引范围；count小于0；startIndex加上count超过源字符串范围</exception>
        /// <exception cref="System.ArgumentNullException">target为Null或者为空字符串</exception>
        /// <remarks>索引从0开始<br/>区分大小写<br/>不区分区域
        /// </remarks>
        /// <history>
        /// [zanezeng]   2008-9-25 1:05 PM    Created
        /// </history>
        public static int IndexOf( string source, string target, int startIndex, int count )
        {
            return IndexOf( source, target, startIndex, count, CultureInfo.CurrentCulture, CompareOptions.None );
        }

        /// <summary>
        /// 搜索指定的字符串，并返回源字符串内从指定的索引位置起指定数目个字符范围内这一部分中第一个匹配项的从零开始的索引
        /// </summary>
        /// <param name="source">用于检索的源字符串</param>
        /// <param name="target">要查找的字符串</param>
        /// <param name="startIndex">从零开始的搜索的起始索引</param>
        /// <param name="count">从指定位置开始的字符个数</param>
        /// <param name="culture">区域信息，使用指定区域相关的字符比较规则</param>
        /// <param name="options">字符比较的选项</param>
        /// <returns>
        /// 如果找到该字符，则为目标字符串的索引位置；否则如果未找到，则为 -1；如果source为Null或者空字符串，则为-1
        /// </returns>
        /// <remarks>索引从0开始
        /// </remarks>
        /// <exception cref="System.ArgumentOutOfRangeException">startIndex小于0或者startIndex 超出了 source 的有效索引范围；count小于0；startIndex加上count超过源字符串范围</exception>
        /// <exception cref="System.ArgumentNullException"><paramref name="target"/>为Null或者为空字符串</exception>
        /// <history>
        /// [zanezeng]   2008-9-25 1:05 PM    Created
        /// </history>
        public static int IndexOf( string source, string target, int startIndex, int count, CultureInfo culture, CompareOptions options )
        {
            //断言参数
            if (null == target)
            {
                //抛出异常
                throw new ArgumentNullException( "target" );
            }

            //判断源字符串是否为Null
            if (null == source)
            {
                //如果字符串为Null，则返回-1
                return -1;
            }

            //判断源字符串是否为空
            if (string.IsNullOrEmpty( source ))
            {
                //判断目标字符串是否为空
                if (string.IsNullOrEmpty( target ))
                {
                    //如果两个字符串都为空，则返回0
                    return 0;
                }

                //如果目标字符串不为空，则返回-1
                return -1;
            }

            //断言参数
            ArgumentAssert.AssertArgumentRange( startIndex, 0, source.Length - 1, "startIndex" );
            ArgumentAssert.AssertArgumentRange( count, 0, source.Length, "count" );
            ArgumentAssert.AssertArgumentRange( startIndex + count - 1, 0, source.Length - 1, "count" );

            //判断区域信息是否为Null
            if (null == culture)
            {
                //如果区域信息为Null，则设置为当前默认的区域信息
                culture = CultureInfo.CurrentCulture;
            }

            //返回索引位置
            return culture.CompareInfo.IndexOf( source, target, startIndex, count, options );
        }

        #endregion

        #region ---LastIndexOf

        /// <summary>
        /// 获得目标字符在源字符串中的最后一个匹配项的索引位置
        /// </summary>
        /// <param name="source">用于检索的源字符串</param>
        /// <param name="target">要查找的字符</param>
        /// <returns>
        /// 如果找到该字符，则为目标字符的索引位置；否则如果未找到，则为 -1；如果source为Null或者空字符串，则为-1
        /// </returns>
        /// <remarks>索引从0开始<br/>区分大小写<br/>不区分区域
        /// </remarks>
        /// <history>
        /// [zanezeng]   2008-9-25 1:05 PM    Created
        /// </history>
        public static int LastIndexOf( string source, char target )
        {
            //转调
            return LastIndexOf( source, target, GetStringLenght( source ) - 1, GetStringLenght( source ), CultureInfo.CurrentCulture, CompareOptions.None );
        }

        /// <summary>
        /// 获得目标字符在源字符串中的最后一个匹配项的索引位置
        /// </summary>
        /// <param name="source">用于检索的源字符串</param>
        /// <param name="target">要查找的字符</param>
        /// <param name="culture">区域信息，使用指定区域相关的字符比较规则</param>
        /// <param name="options">字符比较的选项</param>
        /// <returns>
        /// 如果找到该字符，则为目标字符的索引位置；否则如果未找到，则为 -1；如果source为Null或者空字符串，则为-1
        /// </returns>
        /// <remarks>索引从0开始
        /// </remarks>
        /// <history>
        /// [zanezeng]   2008-9-25 1:05 PM    Created
        /// </history>
        public static int LastIndexOf( string source, char target, CultureInfo culture, CompareOptions options )
        {
            return LastIndexOf( source, target, GetStringLenght( source ) - 1, GetStringLenght( source ), culture, options );
        }

        /// <summary>
        /// 搜索指定的字符，并返回源字符串内从指定的索引位置到字符串结尾这一部分中最后一个匹配项的从零开始的索引
        /// </summary>
        /// <param name="source">用于检索的源字符串</param>
        /// <param name="target">要查找的字符</param>
        /// <param name="startIndex">从零开始的搜索的起始索引</param>
        /// <returns>
        /// 如果找到该字符，则为目标字符的索引位置；否则如果未找到，则为 -1；如果source为Null或者空字符串，则为-1
        /// </returns>
        /// <exception cref="System.ArgumentOutOfRangeException">startIndex小于0或者startIndex 超出了 source 的有效索引范围</exception>
        /// <remarks>索引从0开始<br/>区分大小写<br/>不区分区域
        /// </remarks>
        /// <history>
        /// [zanezeng]   2008-9-25 1:05 PM    Created
        /// </history>
        public static int LastIndexOf( string source, char target, int startIndex )
        {
            return LastIndexOf( source, target, startIndex, startIndex + 1, CultureInfo.CurrentCulture, CompareOptions.None );
        }

        /// <summary>
        /// 搜索指定的字符，并返回源字符串内从指定的索引位置到字符串结尾这一部分中最后一个匹配项的从零开始的索引
        /// </summary>
        /// <param name="source">用于检索的源字符串</param>
        /// <param name="target">要查找的字符</param>
        /// <param name="startIndex">从零开始的搜索的起始索引</param>
        /// <param name="culture">区域信息，使用指定区域相关的字符比较规则</param>
        /// <param name="options">字符比较的选项</param>
        /// <returns>
        /// 如果找到该字符，则为目标字符的索引位置；否则如果未找到，则为 -1；如果source为Null或者空字符串，则为-1
        /// </returns>
        /// <remarks>索引从0开始
        /// </remarks>
        /// <exception cref="System.ArgumentOutOfRangeException">startIndex小于0或者startIndex 超出了 source 的有效索引范围</exception>
        /// <history>
        /// [zanezeng]   2008-9-25 1:05 PM    Created
        /// </history>
        public static int LastIndexOf( string source, char target, int startIndex, CultureInfo culture, CompareOptions options )
        {
            return LastIndexOf( source, target, startIndex, startIndex + 1, culture, options );
        }

        /// <summary>
        /// 搜索指定的字符，并返回源字符串内从指定的索引位置起指定数目个字符范围内这一部分中最后一个匹配项的从零开始的索引
        /// </summary>
        /// <param name="source">用于检索的源字符串</param>
        /// <param name="target">要查找的字符</param>
        /// <param name="startIndex">从零开始的搜索的起始索引</param>
        /// <param name="count">从指定位置开始的字符个数</param>
        /// <returns>
        /// 如果找到该字符，则为目标字符的索引位置；否则如果未找到，则为 -1；如果source为Null或者空字符串，则为-1
        /// </returns>
        /// <exception cref="System.ArgumentOutOfRangeException">startIndex小于0或者startIndex 超出了 source 的有效索引范围；count小于0；startIndex减去count小于0</exception>
        /// <remarks>索引从0开始<br/>区分大小写<br/>不区分区域
        /// </remarks>
        /// <history>
        /// [zanezeng]   2008-9-25 1:05 PM    Created
        /// </history>
        public static int LastIndexOf( string source, char target, int startIndex, int count )
        {
            return LastIndexOf( source, target, startIndex, count, CultureInfo.CurrentCulture, CompareOptions.None );
        }

        /// <summary>
        /// 搜索指定的字符，并返回源字符串内从指定的索引位置起指定数目个字符范围内这一部分中最后一个匹配项的从零开始的索引
        /// </summary>
        /// <param name="source">用于检索的源字符串</param>
        /// <param name="target">要查找的字符</param>
        /// <param name="startIndex">从零开始的搜索的起始索引</param>
        /// <param name="count">从指定位置开始的字符个数</param>
        /// <param name="culture">区域信息，使用指定区域相关的字符比较规则</param>
        /// <param name="options">字符比较的选项</param>
        /// <returns>
        /// 如果找到该字符，则为目标字符的索引位置；否则如果未找到，则为 -1；如果source为Null或者空字符串，则为-1
        /// </returns>
        /// <remarks>索引从0开始
        /// </remarks>
        /// <exception cref="System.ArgumentOutOfRangeException">startIndex小于0或者startIndex 超出了 source 的有效索引范围；count小于0；startIndex减去count小于0</exception>
        /// <history>
        /// [zanezeng]   2008-9-25 1:05 PM    Created
        /// </history>
        public static int LastIndexOf( string source, char target, int startIndex, int count, CultureInfo culture, CompareOptions options )
        {
            //判断字符串是否为空
            if (string.IsNullOrEmpty( source ))
            {
                //如果字符串为空，则返回-1
                return -1;
            }

            //断言参数
            ArgumentAssert.AssertArgumentRange( startIndex, 0, source.Length - 1, "startIndex" );
            ArgumentAssert.AssertArgumentRange( count, 0, source.Length, "count" );
            ArgumentAssert.AssertArgumentRange( startIndex - count + 1, 0, source.Length - 1, "count" );

            //判断区域信息是否为Null
            if (null == culture)
            {
                //如果区域信息为Null，则设置为当前默认的区域信息
                culture = CultureInfo.CurrentCulture;
            }

            //返回索引位置
            return culture.CompareInfo.LastIndexOf( source, target, startIndex, count, options );
        }

        /// <summary>
        /// 获得目标字符串在源字符串中的最后一个匹配项的索引位置
        /// </summary>
        /// <param name="source">用于检索的源字符串</param>
        /// <param name="target">要查找的字符串</param>
        /// <returns>
        /// 如果找到该字符，则为目标字符串的索引位置；否则如果未找到，则为 -1；如果source为Null或者空字符串，则为-1
        /// </returns>
        /// <remarks>索引从0开始<br/>区分大小写<br/>不区分区域
        /// </remarks>
        /// <exception cref="System.ArgumentNullException">target为Null或者为空字符串</exception>
        /// <history>
        /// [zanezeng]   2008-9-25 1:05 PM    Created
        /// </history>
        public static int LastIndexOf( string source, string target )
        {
            return LastIndexOf( source, target, GetStringLenght( source ) - 1, GetStringLenght( source ), CultureInfo.CurrentCulture, CompareOptions.None );
        }

        /// <summary>
        /// 获得目标字符串在源字符串中的最后一个匹配项的索引位置
        /// </summary>
        /// <param name="source">用于检索的源字符串</param>
        /// <param name="target">要查找的字符串</param>
        /// <param name="culture">区域信息，使用指定区域相关的字符比较规则</param>
        /// <param name="options">字符比较的选项</param>
        /// <returns>
        /// 如果找到该字符，则为目标字符串的索引位置；否则如果未找到，则为 -1；如果source为Null或者空字符串，则为-1
        /// </returns>
        /// <remarks>索引从0开始
        /// </remarks>
        /// <exception cref="System.ArgumentNullException">target为Null或者为空字符串</exception>
        /// <history>
        /// [zanezeng]   2008-9-25 1:05 PM    Created
        /// </history>
        public static int LastIndexOf( string source, string target, CultureInfo culture, CompareOptions options )
        {
            return LastIndexOf( source, target, GetStringLenght( source ) - 1, GetStringLenght( source ), culture, options );
        }

        /// <summary>
        /// 搜索指定的字符串，并返回源字符串内从指定的索引位置到字符串结尾这一部分中最后一个匹配项的从零开始的索引
        /// </summary>
        /// <param name="source">用于检索的源字符串</param>
        /// <param name="target">要查找的字符串</param>
        /// <param name="startIndex">从零开始的搜索的起始索引</param>
        /// <returns>
        /// 如果找到该字符，则为目标字符串的索引位置；否则如果未找到，则为 -1；如果source为Null或者空字符串，则为-1
        /// </returns>
        /// <exception cref="System.ArgumentOutOfRangeException">startIndex小于0或者startIndex 超出了 source 的有效索引范围</exception>
        /// <exception cref="System.ArgumentNullException">target为Null或者为空字符串</exception>
        /// <remarks>索引从0开始<br/>区分大小写<br/>不区分区域
        /// </remarks>
        /// <history>
        /// [zanezeng]   2008-9-25 1:05 PM    Created
        /// </history>
        public static int LastIndexOf( string source, string target, int startIndex )
        {
            return LastIndexOf( source, target, startIndex, startIndex + 1, CultureInfo.CurrentCulture, CompareOptions.None );
        }

        /// <summary>
        /// 搜索指定的字符串，并返回源字符串内从指定的索引位置到字符串结尾这一部分中最后一个匹配项的从零开始的索引
        /// </summary>
        /// <param name="source">用于检索的源字符串</param>
        /// <param name="target">要查找的字符串</param>
        /// <param name="startIndex">从零开始的搜索的起始索引</param>
        /// <param name="culture">区域信息，使用指定区域相关的字符比较规则</param>
        /// <param name="options">字符比较的选项</param>
        /// <returns>
        /// 如果找到该字符，则为目标字符串的索引位置；否则如果未找到，则为 -1；如果source为Null或者空字符串，则为-1
        /// </returns>
        /// <remarks>索引从0开始
        /// </remarks>
        /// <exception cref="System.ArgumentOutOfRangeException">startIndex小于0或者startIndex 超出了 source 的有效索引范围</exception>
        /// <exception cref="System.ArgumentNullException">target为Null或者为空字符串</exception>
        /// <history>
        /// [zanezeng]   2008-9-25 1:05 PM    Created
        /// </history>
        public static int LastIndexOf( string source, string target, int startIndex, CultureInfo culture, CompareOptions options )
        {
            return LastIndexOf( source, target, startIndex, startIndex + 1, culture, options );
        }

        /// <summary>
        /// 搜索指定的字符串，并返回源字符串内从指定的索引位置起指定数目个字符范围内这一部分中最后一个匹配项的从零开始的索引
        /// </summary>
        /// <param name="source">用于检索的源字符串</param>
        /// <param name="target">要查找的字符串</param>
        /// <param name="startIndex">从零开始的搜索的起始索引</param>
        /// <param name="count">从指定位置开始的字符个数</param>
        /// <returns>
        /// 如果找到该字符，则为目标字符串的索引位置；否则如果未找到，则为 -1；如果source为Null或者空字符串，则为-1
        /// </returns>
        /// <exception cref="System.ArgumentOutOfRangeException">startIndex小于0或者startIndex 超出了 source 的有效索引范围；count小于0；startIndex减去count小于0</exception>
        /// <exception cref="System.ArgumentNullException">target为Null或者为空字符串</exception>
        /// <remarks>索引从0开始<br/>区分大小写<br/>不区分区域
        /// </remarks>
        /// <history>
        /// [zanezeng]   2008-9-25 1:05 PM    Created
        /// </history>
        public static int LastIndexOf( string source, string target, int startIndex, int count )
        {
            return LastIndexOf( source, target, startIndex, count, CultureInfo.CurrentCulture, CompareOptions.None );
        }

        /// <summary>
        /// 搜索指定的字符串，并返回源字符串内从指定的索引位置起指定数目个字符范围内这一部分中最后一个匹配项的从零开始的索引
        /// </summary>
        /// <param name="source">用于检索的源字符串</param>
        /// <param name="target">要查找的字符串</param>
        /// <param name="startIndex">从零开始的搜索的起始索引</param>
        /// <param name="count">从指定位置开始的字符个数</param>
        /// <param name="culture">区域信息，使用指定区域相关的字符比较规则</param>
        /// <param name="options">字符比较的选项</param>
        /// <returns>
        /// 如果找到该字符，则为目标字符串的索引位置；否则如果未找到，则为 -1；如果source为Null或者空字符串，则为-1
        /// </returns>
        /// <remarks>索引从0开始
        /// </remarks>
        /// <exception cref="System.ArgumentOutOfRangeException">startIndex小于0或者startIndex 超出了 source 的有效索引范围；count小于0；startIndex减去count小于0</exception>
        /// <exception cref="System.ArgumentNullException">target为Null或者为空字符串</exception>
        /// <history>
        /// [zanezeng]   2008-9-25 1:05 PM    Created
        /// </history>
        public static int LastIndexOf( string source, string target, int startIndex, int count, CultureInfo culture, CompareOptions options )
        {
            //断言参数
            if (null == target)
            {
                //抛出异常
                throw new ArgumentNullException( "target" );
            }

            //判断源字符串是否为Null
            if (null == source)
            {
                //如果字符串为Null，则返回-1
                return -1;
            }

            //判断目标字符串是否为空
            if (string.IsNullOrEmpty( target ))
            {
                //如果两个字符串都为空，则返回最后一个元素的位置
                return source.Length - 1;
            }

            //判断源字符串是否为空
            if (string.IsNullOrEmpty( source ))
            {
                //如果目标字符串不为空，则返回-1
                return -1;
            }

            //断言参数
            ArgumentAssert.AssertArgumentRange( startIndex, 0, source.Length - 1, "startIndex" );
            ArgumentAssert.AssertArgumentRange( count, 0, source.Length, "count" );
            ArgumentAssert.AssertArgumentRange( startIndex - count + 1, 0, source.Length - 1, "count" );

            //判断区域信息是否为Null
            if (null == culture)
            {
                //如果区域信息为Null，则设置为当前默认的区域信息
                culture = CultureInfo.CurrentCulture;
            }

            //返回索引位置
            return culture.CompareInfo.LastIndexOf( source, target, startIndex, count, options );
        }

        #endregion

        #region ---IndexOfAny

        /// <summary>
        /// 搜索源字符串，获得目标字符数组中任何一个字符在源字符串中的第一个匹配项的索引位置
        /// </summary>
        /// <param name="source">检索的源字符串</param>
        /// <param name="target">目标字符数组</param>
        /// <returns>
        /// 如果找到该字符，则为目标字符的索引位置；否则如果未找到，则为 -1；如果source为Null或者空字符串，则为-1
        /// </returns>
        /// <remarks></remarks>
        /// <exception cref="System.ArgumentNullException">target为Null或者为空数组</exception>
        /// <history>
        /// [zanezeng]   2008-9-25 1:39 PM    Created
        /// </history>
        public static int IndexOfAny( string source, char[] target )
        {
            return IndexOfAny( source, target, 0, GetStringLenght( source ), CultureInfo.CurrentCulture, CompareOptions.None );
        }

        /// <summary>
        /// 搜索指定的字符串，并返回目标字符数组中任何一个字符在源字符串内从指定的索引位置起到结尾这一部分范围中第一个匹配项的索引
        /// </summary>
        /// <param name="source">检索的源字符串</param>
        /// <param name="target">目标字符数组</param>
        /// <param name="startIndex">从零开始的搜索的起始索引</param>
        /// <returns>
        /// 如果找到该字符，则为目标字符的索引位置；否则如果未找到，则为 -1；如果source为Null或者空字符串，则为-1
        /// </returns>
        /// <remarks></remarks>
        /// <exception cref="System.ArgumentNullException">target为Null或者为空数组</exception>
        /// <exception cref="System.ArgumentOutOfRangeException">startIndex小于0或者startIndex 超出了 source 的有效索引范围；</exception>
        /// <history>
        /// [zanezeng]   2008-9-25 1:39 PM    Created
        /// </history>
        public static int IndexOfAny( string source, char[] target, int startIndex )
        {
            return IndexOfAny( source, target, startIndex, GetStringLenght( source ) - startIndex, CultureInfo.CurrentCulture, CompareOptions.None );
        }

        /// <summary>
        /// 搜索指定的字符串，并返回目标字符数组中任何一个字符在源字符串内从指定的索引位置起指定数目个字符范围内这一部分中第一个匹配项的索引
        /// </summary>
        /// <param name="source">检索的源字符串</param>
        /// <param name="target">目标字符数组</param>
        /// <param name="startIndex">从零开始的搜索的起始索引</param>
        /// <param name="count">从指定位置开始的字符个数</param>
        /// <returns>
        /// 如果找到该字符，则为目标字符的索引位置；否则如果未找到，则为 -1；如果source为Null或者空字符串，则为-1
        /// </returns>
        /// <remarks></remarks>
        /// <exception cref="System.ArgumentNullException">target为Null或者为空数组</exception>
        /// <exception cref="System.ArgumentOutOfRangeException">startIndex小于0或者startIndex 超出了 source 的有效索引范围；count小于0；startIndex加上count超过源字符串范围</exception>
        /// <history>
        /// [zanezeng]   2008-9-25 1:39 PM    Created
        /// </history>
        public static int IndexOfAny( string source, char[] target, int startIndex, int count )
        {
            return IndexOfAny( source, target, startIndex, count, CultureInfo.CurrentCulture, CompareOptions.None );
        }

        /// <summary>
        /// 搜索源字符串，获得目标字符数组中任何一个字符在源字符串中的第一个匹配项的索引位置
        /// </summary>
        /// <param name="source">检索的源字符串</param>
        /// <param name="target">目标字符数组</param>
        /// <param name="culture">区域信息，使用指定区域相关的字符比较规则</param>
        /// <param name="options">字符比较的选项</param>
        /// <returns>
        /// 如果找到该字符，则为目标字符的索引位置；否则如果未找到，则为 -1；如果source为Null或者空字符串，则为-1
        /// </returns>
        /// <remarks></remarks>
        /// <exception cref="System.ArgumentNullException">target为Null或者为空数组</exception>
        /// <history>
        /// [zanezeng]   2008-9-25 1:39 PM    Created
        /// </history>
        public static int IndexOfAny( string source, char[] target, CultureInfo culture, CompareOptions options )
        {
            return IndexOfAny( source, target, 0, GetStringLenght( source ), culture, options );
        }

        /// <summary>
        /// 搜索指定的字符串，并返回目标字符数组中任何一个字符在源字符串内从指定的索引位置起到结尾这一部分范围中第一个匹配项的索引
        /// </summary>
        /// <param name="source">检索的源字符串</param>
        /// <param name="target">目标字符数组</param>
        /// <param name="startIndex">从零开始的搜索的起始索引</param>
        /// <param name="culture">区域信息，使用指定区域相关的字符比较规则</param>
        /// <param name="options">字符比较的选项</param>
        /// <returns>
        /// 如果找到该字符，则为目标字符的索引位置；否则如果未找到，则为 -1；如果source为Null或者空字符串，则为-1
        /// </returns>
        /// <remarks></remarks>
        /// <exception cref="System.ArgumentNullException">target为Null或者为空数组</exception>
        /// <exception cref="System.ArgumentOutOfRangeException">startIndex小于0或者startIndex 超出了 source 的有效索引范围；</exception>
        /// <history>
        /// [zanezeng]   2008-9-25 1:39 PM    Created
        /// </history>
        public static int IndexOfAny( string source, char[] target, int startIndex, CultureInfo culture, CompareOptions options )
        {
            return IndexOfAny( source, target, startIndex, GetStringLenght( source ) - startIndex, culture, options );
        }

        /// <summary>
        /// 搜索指定的字符串，并返回目标字符数组中任何一个字符在源字符串内从指定的索引位置起指定数目个字符范围内这一部分中第一个匹配项的索引
        /// </summary>
        /// <param name="source">检索的源字符串</param>
        /// <param name="target">目标字符数组</param>
        /// <param name="startIndex">从零开始的搜索的起始索引</param>
        /// <param name="count">从指定位置开始的字符个数</param>
        /// <param name="culture">区域信息，使用指定区域相关的字符比较规则</param>
        /// <param name="options">字符比较的选项</param>
        /// <returns>
        /// 如果找到该字符，则为目标字符的索引位置；否则如果未找到，则为 -1；如果source为Null或者空字符串，则为-1
        /// </returns>
        /// <remarks></remarks>
        /// <exception cref="System.ArgumentNullException">target为Null或者为空数组</exception>
        /// <exception cref="System.ArgumentOutOfRangeException">startIndex小于0或者startIndex 超出了 source 的有效索引范围；count小于0；startIndex加上count超过源字符串范围</exception>
        /// <history>
        /// [zanezeng]   2008-9-25 1:39 PM    Created
        /// </history>
        public static int IndexOfAny( string source, char[] target, int startIndex, int count, CultureInfo culture, CompareOptions options )
        {
            //断言参数
            if (null == target)
            {
                //抛出异常
                throw new ArgumentNullException( "target" );
            }

            //判断源字符串是否为Null
            if (null == source)
            {
                //如果字符串为Null，则返回-1
                return -1;
            }

            //判断目标字符串是否为空
            if (CollectionUtility.IsNullOrEmpty( target ))
            {
                //如果两个字符串都为空，则返回0
                return 0;
            }

            //判断源字符串是否为空
            if (string.IsNullOrEmpty( source ))
            {
                //如果目标字符串不为空，则返回-1
                return -1;
            }

            //断言参数
            ArgumentAssert.AssertArgumentRange( startIndex, 0, source.Length - 1, "startIndex" );
            ArgumentAssert.AssertArgumentRange( count, 0, source.Length, "count" );
            ArgumentAssert.AssertArgumentRange( startIndex + count - 1, 0, source.Length - 1, "count" );

            //判断区域信息是否为Null
            if (null == culture)
            {
                //如果区域信息为Null，则设置为当前默认的区域信息
                culture = CultureInfo.CurrentCulture;
            }

            //连接为字符串
            string targetString = new string( target );

            //循环比较
            for (int index = startIndex; index <= startIndex + count - 1; index++)
            {
                //判断是否存在
                if (-1 != culture.CompareInfo.IndexOf( targetString, source[index], options ))
                {
                    //如果存在，则返回序号
                    return index;
                }
            }

            //默认没有找到
            return -1;
        }

        #endregion

        #region ---LastIndexOfAny

        /// <summary>
        /// 搜索源字符串，获得目标字符数组中任何一个字符在源字符串中的最后一个匹配项的索引位置
        /// </summary>
        /// <param name="source">检索的源字符串</param>
        /// <param name="target">目标字符数组</param>
        /// <returns>
        /// 如果找到该字符，则为目标字符的索引位置；否则如果未找到，则为 -1；如果source为Null或者空字符串，则为-1
        /// </returns>
        /// <remarks></remarks>
        /// <exception cref="System.ArgumentNullException">target为Null或者为空数组</exception>
        /// <history>
        /// [zanezeng]   2008-9-25 1:39 PM    Created
        /// </history>
        public static int LastIndexOfAny( string source, char[] target )
        {
            return LastIndexOfAny( source, target, GetStringLenght( source ) - 1, GetStringLenght( source ), CultureInfo.CurrentCulture, CompareOptions.None );
        }

        /// <summary>
        /// 搜索指定的字符串，并返回目标字符数组中任何一个字符在源字符串内从指定的索引位置起到结尾这一部分范围中最后一个匹配项的索引
        /// </summary>
        /// <param name="source">检索的源字符串</param>
        /// <param name="target">目标字符数组</param>
        /// <param name="startIndex">从零开始的搜索的起始索引</param>
        /// <returns>
        /// 如果找到该字符，则为目标字符的索引位置；否则如果未找到，则为 -1；如果source为Null或者空字符串，则为-1
        /// </returns>
        /// <remarks></remarks>
        /// <exception cref="System.ArgumentNullException">target为Null或者为空数组</exception>
        /// <exception cref="System.ArgumentOutOfRangeException">startIndex小于0或者startIndex 超出了 source 的有效索引范围；</exception>
        /// <history>
        /// [zanezeng]   2008-9-25 1:39 PM    Created
        /// </history>
        public static int LastIndexOfAny( string source, char[] target, int startIndex )
        {
            return IndexOfAny( source, target, startIndex, startIndex + 1, CultureInfo.CurrentCulture, CompareOptions.None );
        }

        /// <summary>
        /// 搜索指定的字符串，并返回目标字符数组中任何一个字符在源字符串内从指定的索引位置起指定数目个字符范围内这一部分中最后一个匹配项的索引
        /// </summary>
        /// <param name="source">检索的源字符串</param>
        /// <param name="target">目标字符数组</param>
        /// <param name="startIndex">从零开始的搜索的起始索引</param>
        /// <param name="count">从指定位置开始的字符个数</param>
        /// <returns>
        /// 如果找到该字符，则为目标字符的索引位置；否则如果未找到，则为 -1；如果source为Null或者空字符串，则为-1
        /// </returns>
        /// <remarks></remarks>
        /// <exception cref="System.ArgumentNullException">target为Null或者为空数组</exception>
        /// <exception cref="System.ArgumentOutOfRangeException">startIndex小于0或者startIndex 超出了 source 的有效索引范围；count小于0；startIndex减去count小于0</exception>
        /// <history>
        /// [zanezeng]   2008-9-25 1:39 PM    Created
        /// </history>
        public static int LastIndexOfAny( string source, char[] target, int startIndex, int count )
        {
            return IndexOfAny( source, target, startIndex, count, CultureInfo.CurrentCulture, CompareOptions.None );
        }

        /// <summary>
        /// 搜索源字符串，获得目标字符数组中任何一个字符在源字符串中的最后一个匹配项的索引位置
        /// </summary>
        /// <param name="source">检索的源字符串</param>
        /// <param name="target">目标字符数组</param>
        /// <param name="culture">区域信息，使用指定区域相关的字符比较规则</param>
        /// <param name="options">字符比较的选项</param>
        /// <returns>
        /// 如果找到该字符，则为目标字符的索引位置；否则如果未找到，则为 -1；如果source为Null或者空字符串，则为-1
        /// </returns>
        /// <remarks></remarks>
        /// <exception cref="System.ArgumentNullException">target为Null或者为空数组</exception>
        /// <history>
        /// [zanezeng]   2008-9-25 1:39 PM    Created
        /// </history>
        public static int LastIndexOfAny( string source, char[] target, CultureInfo culture, CompareOptions options )
        {
            return IndexOfAny( source, target, GetStringLenght( source ) - 1, GetStringLenght( source ), culture, options );
        }

        /// <summary>
        /// 搜索指定的字符串，并返回目标字符数组中任何一个字符在源字符串内从指定的索引位置起到结尾这一部分范围中最后一个匹配项的索引
        /// </summary>
        /// <param name="source">检索的源字符串</param>
        /// <param name="target">目标字符数组</param>
        /// <param name="startIndex">从零开始的搜索的起始索引</param>
        /// <param name="culture">区域信息，使用指定区域相关的字符比较规则</param>
        /// <param name="options">字符比较的选项</param>
        /// <returns>
        /// 如果找到该字符，则为目标字符的索引位置；否则如果未找到，则为 -1；如果source为Null或者空字符串，则为-1
        /// </returns>
        /// <remarks></remarks>
        /// <exception cref="System.ArgumentNullException">target为Null或者为空数组</exception>
        /// <exception cref="System.ArgumentOutOfRangeException">startIndex小于0或者startIndex 超出了 source 的有效索引范围；</exception>
        /// <history>
        /// [zanezeng]   2008-9-25 1:39 PM    Created
        /// </history>
        public static int LastIndexOfAny( string source, char[] target, int startIndex, CultureInfo culture, CompareOptions options )
        {
            return IndexOfAny( source, target, startIndex, startIndex + 1, culture, options );
        }

        /// <summary>
        /// 搜索指定的字符串，并返回目标字符数组中任何一个字符在源字符串内从指定的索引位置起指定数目个字符范围内这一部分中最后一个匹配项的索引
        /// </summary>
        /// <param name="source">检索的源字符串</param>
        /// <param name="target">目标字符数组</param>
        /// <param name="startIndex">从零开始的搜索的起始索引</param>
        /// <param name="count">从指定位置开始的字符个数</param>
        /// <param name="culture">区域信息，使用指定区域相关的字符比较规则</param>
        /// <param name="options">字符比较的选项</param>
        /// <returns>
        /// 如果找到该字符，则为目标字符的索引位置；否则如果未找到，则为 -1；如果source为Null或者空字符串，则为-1
        /// </returns>
        /// <remarks></remarks>
        /// <exception cref="System.ArgumentNullException">target为Null或者为空数组</exception>
        /// <exception cref="System.ArgumentOutOfRangeException">startIndex小于0或者startIndex 超出了 source 的有效索引范围；count小于0；startIndex减去count小于0</exception>
        /// <history>
        /// [zanezeng]   2008-9-25 1:39 PM    Created
        /// </history>
        public static int LastIndexOfAny( string source, char[] target, int startIndex, int count, CultureInfo culture, CompareOptions options )
        {
            //断言参数
            if (null == target)
            {
                //抛出异常
                throw new ArgumentNullException( "target" );
            }

            //判断源字符串是否为Null
            if (null == source)
            {
                //如果字符串为Null，则返回-1
                return -1;
            }

            //判断目标字符串是否为空
            if (CollectionUtility.IsNullOrEmpty( target ))
            {
                //如果两个字符串都为空，则返回0
                return 0;
            }

            //判断源字符串是否为空
            if (string.IsNullOrEmpty( source ))
            {
                //如果目标字符串不为空，则返回-1
                return -1;
            }

            //断言参数
            ArgumentAssert.AssertArgumentRange( startIndex, 0, source.Length - 1, "startIndex" );
            ArgumentAssert.AssertArgumentRange( count, 0, source.Length, "count" );
            ArgumentAssert.AssertArgumentRange( startIndex - count + 1, 0, source.Length - 1, "count" );

            //判断区域信息是否为Null
            if (null == culture)
            {
                //如果区域信息为Null，则设置为当前默认的区域信息
                culture = CultureInfo.CurrentCulture;
            }

            //判断count是否小于0
            if (count < 0)
            {
                //如果count小于0，则设置为剩余长度
                count = source.Length - startIndex;
            }

            //连接为字符串
            string targetString = new string( target );

            //循环比较
            for (int index = startIndex; index >= startIndex - count + 1; index--)
            {
                //判断是否存在
                if (-1 != culture.CompareInfo.IndexOf( targetString, source[index], options ))
                {
                    //如果存在，则返回序号
                    return index;
                }
            }

            //默认没有找到
            return -1;
        }

        #endregion

        #region ---QueryString

        /// <summary>
        /// 从查询字符串中解析查询参数
        /// </summary>
        /// <param name="queryString">需要进行解析的查询字符串</param>
        /// <param name="urlEncoded">查询字符串是否进行了URL编码，True进行了URL编码</param>
        /// <param name="encoding">当前字符串的编码方式</param>
        /// <returns>
        /// 包含查询参数的Dictionary，如果查询字符串为Null或者为空，直接返回空的Dictionary
        /// </returns>
        /// <remarks>不包含Key为空的数据</remarks>
        /// <history>
        /// [zanezeng]   2008-10-14 2:00 PM    Created
        /// </history>
        public static IDictionary<string, string> ParseQueryString( string queryString, bool urlEncoded, Encoding encoding )
        {
            //用于保存结果的Dictionary
            Dictionary<string, string> result = new Dictionary<string, string>();

            //判断是否为空
            if (!StringUtility.HasText( queryString ))
            {
                return result;
            }

            //去掉空格
            queryString = queryString.Trim();

            //判断第一个字符是否为？
            if ('?' == queryString[0])
            {
                //去掉？
                queryString = queryString.Substring( 1 );
            }

            //用于记录总长度
            int length = queryString.Length;

            //用于记录其实位置
            int startIndex = 0;

            //用于记录等号的位置
            int equalIndex = 0;

            //用于保存字符
            char currentChar;

            //用于记录Key
            string key;

            //用于记录值
            string value;

            //循环进行处理
            //需要注意的是第一个字符为?
            for (int i = 0; i < length; i++)
            {
                //记录起始位置
                startIndex = i;

                //设置等号位置
                equalIndex = -1;

                //循环
                while (i < length)
                {
                    //获得当前字符
                    currentChar = queryString[i];

                    //判断是否为=
                    if ('=' == currentChar)
                    {
                        //只记录第一个等号的位置
                        if (equalIndex < 0)
                        {
                            equalIndex = i;
                        }
                    }
                    else if ('&' == currentChar)
                    {
                        //终止循环
                        break;
                    }

                    //增加序号
                    i++;
                }

                //判断是否包含值
                if (equalIndex > 0)
                {
                    //获得Key
                    key = queryString.Substring( startIndex, equalIndex - startIndex );

                    //获得值
                    value = queryString.Substring( equalIndex + 1, i - equalIndex - 1 );
                }
                else
                {
                    //整个全部都是参数名称
                    //获得Key
                    key = queryString.Substring( startIndex, i - startIndex );

                    //设置值为空
                    value = null;
                }

                //如果Key为空则不添加
                if (!string.IsNullOrEmpty( key ))
                {
                    //添加
                    if (urlEncoded)
                    {
                        //进行URL解码
                        result.Add( System.Web.HttpUtility.UrlDecode( key, encoding ), System.Web.HttpUtility.UrlDecode( value, encoding ) );
                    }
                    else
                    {
                        //直接添加
                        result.Add( key, value );
                    }
                }
            }

            //返回结果
            return result;
        }

        /// <summary>
        /// 根据参数列表生成查询字符串
        /// </summary>
        /// <param name="arguments">参数列表</param>
        /// <param name="urlEncode">是否对QueryString进行URL编码，True进行URL编码</param>
        /// <param name="encoding">当前字符串的编码方式</param>
        /// <returns>根据参数列表生成的QueryString，如果参数列表为Null或者为空，则返回空字符串</returns>
        /// <remarks></remarks>
        /// <history>
        /// [zanezeng]   2008-10-14 4:07 PM    Created
        /// </history>
        public static string BuildQueryString( IDictionary<string, string> arguments, bool urlEncode, Encoding encoding )
        {
            //判断是否为空
            if (CollectionUtility.IsNullOrEmpty( arguments ))
            {
                //返回
                return string.Empty;
            }

            //用于生成字符串
            StringBuilder builder = new StringBuilder();

            //获得
            IEnumerator<string> keys = arguments.Keys.GetEnumerator();

            //用于保存Key
            string key;

            //移动到第一个元素
            keys.MoveNext();

            //添加问号
            builder.Append( "?" );

            //循环添加
            while (true)
            {
                //获得Key
                key = keys.Current;

                //编码
                if (urlEncode)
                {
                    //添加名称
                    builder.Append( System.Web.HttpUtility.UrlEncode( key, encoding ) );

                    //添加等号
                    builder.Append( "=" );

                    //添加值
                    builder.Append( System.Web.HttpUtility.UrlEncode( arguments[key], encoding ) );
                }
                else
                {
                    //添加名称
                    builder.Append( key );

                    //添加等号
                    builder.Append( "=" );

                    //添加值
                    builder.Append( arguments[key] );
                }

                //移动到下一个元素
                if (!keys.MoveNext())
                {
                    //退出循环
                    break;
                }

                //添加&
                builder.Append( "&" );
            }

            //返回结果
            return builder.ToString();
        }

        #endregion

        #region ---Replace

        /// <summary>
        /// 将源字符串中的第一个匹配字符串替换为指定字符串
        /// </summary>
        /// <param name="source">源字符串</param>
        /// <param name="target">替换的目标字符串</param>
        /// <param name="replacement">替换字符串</param>
        /// <returns>将源字符串中的第一个匹配字符串替换为指定字符串后的新字符串</returns>
        /// <remarks></remarks>
        /// <history>
        /// [zanezeng]   2008-12-30 15:43    Created
        /// </history>
        public static string ReplaceFirst( string source, string target, string replacement )
        {
            return ReplaceFirst( source, target, replacement, CultureInfo.CurrentCulture, CompareOptions.None );
        }

        /// <summary>
        /// 将源字符串中的第一个匹配字符串替换为指定字符串
        /// </summary>
        /// <param name="source">源字符串</param>
        /// <param name="target">替换的目标字符串</param>
        /// <param name="replacement">替换字符串</param>
        /// <param name="culture">区域信息，使用指定区域相关的字符比较规则</param>
        /// <param name="options">字符比较的选项</param>
        /// <returns>将源字符串中的第一个匹配字符串替换为指定字符串后的新字符串</returns>
        /// <remarks>如果没有找到目标字符串，则返回源字符串</remarks>
        /// <exception cref="T:ArgumentNullException">
        /// <paramref name="target"/>或者<paramref name="replacement"/>为Null
        /// </exception>
        /// <history>
        /// [zanezeng]   2008-12-30 15:43    Created
        /// </history>
        public static string ReplaceFirst( string source, string target, string replacement, CultureInfo culture, CompareOptions options )
        {
            //断言参数
            if (null == target)
            {
                //抛出异常
                throw new ArgumentNullException( "target" );
            }

            //断言参数
            if (null == replacement)
            {
                //抛出异常
                throw new ArgumentNullException( "replacement" );
            }

            //判断源字符串是否为空
            if (string.IsNullOrEmpty( source ))
            {
                //返回源字符串
                return source;
            }

            //判断目标字符串是否为空
            if (string.IsNullOrEmpty( target ))
            {
                //返回源字符串
                return source;
            }

            //获得字符串的索引位置
            int index = culture.CompareInfo.IndexOf( source, target, options );

            //判断是否存在
            if (-1 == index)
            {
                //如果不存在，则返回源字符串
                return source;
            }

            //删除字符
            source = source.Remove( index, target.Length );

            //在指定的位置插入替换字符串
            if (!string.IsNullOrEmpty( replacement ))
            {
                source = source.Insert( index, replacement );
            }

            //返回结果
            return source;
        }

        /// <summary>
        /// 将源字符串中的最后一个匹配字符串替换为指定字符串
        /// </summary>
        /// <param name="source">源字符串</param>
        /// <param name="target">替换的目标字符串</param>
        /// <param name="replacement">替换字符串</param>
        /// <returns>将源字符串中的第一个匹配字符串替换为指定字符串后的新字符串</returns>
        /// <remarks>如果没有找到目标字符串，则返回源字符串</remarks>
        /// <exception cref="T:ArgumentNullException">
        /// 	<paramref name="target"/>或者<paramref name="replacement"/>为Null
        /// </exception>
        /// <history>
        /// [zanezeng]   2008-12-30 15:43    Created
        /// </history>
        public static string ReplaceLast( string source, string target, string replacement )
        {
            return ReplaceLast( source, target, replacement, CultureInfo.CurrentCulture, CompareOptions.None );
        }

        /// <summary>
        /// 将源字符串中的最后一个匹配字符串替换为指定字符串
        /// </summary>
        /// <param name="source">源字符串</param>
        /// <param name="target">替换的目标字符串</param>
        /// <param name="replacement">替换字符串</param>
        /// <param name="culture">区域信息，使用指定区域相关的字符比较规则</param>
        /// <param name="options">字符比较的选项</param>
        /// <returns>将源字符串中的第一个匹配字符串替换为指定字符串后的新字符串</returns>
        /// <remarks>如果没有找到目标字符串，则返回源字符串</remarks>
        /// <exception cref="T:ArgumentNullException">
        /// <paramref name="target"/>或者<paramref name="replacement"/>为Null
        /// </exception>
        /// <history>
        /// [zanezeng]   2008-12-30 15:43    Created
        /// </history>
        public static string ReplaceLast( string source, string target, string replacement, CultureInfo culture, CompareOptions options )
        {
            //断言参数
            if (null == target)
            {
                //抛出异常
                throw new ArgumentNullException( "target" );
            }

            //断言参数
            if (null == replacement)
            {
                //抛出异常
                throw new ArgumentNullException( "replacement" );
            }

            //判断源字符串是否为空
            if (string.IsNullOrEmpty( source ))
            {
                //返回源字符串
                return source;
            }

            //判断目标字符串是否为空
            if (string.IsNullOrEmpty( target ))
            {
                //返回源字符串
                return source;
            }

            //获得字符串的索引位置
            int index = culture.CompareInfo.LastIndexOf( source, target, options );

            //判断是否存在
            if (-1 == index)
            {
                //如果不存在，则返回源字符串
                return source;
            }

            //删除字符
            source = source.Remove( index, target.Length );

            //在指定的位置插入替换字符串
            if (!string.IsNullOrEmpty( replacement ))
            {
                source = source.Insert( index, replacement );
            }

            //返回结果
            return source;
        }

        /// <summary>
        /// 将源字符串中的所有匹配字符串替换为指定字符串
        /// </summary>
        /// <param name="source">源字符串</param>
        /// <param name="target">替换的目标字符串</param>
        /// <param name="replacement">替换字符串</param>
        /// <returns>将源字符串中的第一个匹配字符串替换为指定字符串后的新字符串</returns>
        /// <remarks>如果没有找到目标字符串，则返回源字符串</remarks>
        /// <exception cref="T:ArgumentNullException">
        /// 	<paramref name="target"/>或者<paramref name="replacement"/>为Null
        /// </exception>
        /// <history>
        /// [zanezeng]   2008-12-30 15:43    Created
        /// </history>
        public static string ReplaceAll( string source, string target, string replacement )
        {
            return ReplaceAll( source, target, replacement, CultureInfo.CurrentCulture, CompareOptions.None );
        }

        /// <summary>
        /// 将源字符串中的所有匹配字符串替换为指定字符串
        /// </summary>
        /// <param name="source">源字符串</param>
        /// <param name="target">替换的目标字符串</param>
        /// <param name="replacement">替换字符串</param>
        /// <param name="culture">区域信息，使用指定区域相关的字符比较规则</param>
        /// <param name="options">字符比较的选项</param>
        /// <returns>将源字符串中的第一个匹配字符串替换为指定字符串后的新字符串</returns>
        /// <remarks>如果没有找到目标字符串，则返回源字符串</remarks>
        /// <exception cref="T:ArgumentNullException">
        /// <paramref name="target"/>或者<paramref name="replacement"/>为Null
        /// </exception>
        /// <history>
        /// [zanezeng]   2008-12-30 15:43    Created
        /// </history>
        public static string ReplaceAll( string source, string target, string replacement, CultureInfo culture, CompareOptions options )
        {
            //断言参数
            if (null == target)
            {
                //抛出异常
                throw new ArgumentNullException( "target" );
            }

            //断言参数
            if (null == replacement)
            {
                //抛出异常
                throw new ArgumentNullException( "replacement" );
            }

            //判断源字符串是否为空
            if (string.IsNullOrEmpty( source ))
            {
                //返回源字符串
                return source;
            }

            //执行替换
            return source.Replace( target, replacement );
        }

        #endregion

        #region ---Distinct

        /// <summary>
        /// 消除指定字符串集合中的重复值
        /// </summary>
        /// <param name="values">需要消除重复值的字符串集合</param>
        /// <param name="ignoreCase">是否忽略字符的大小写</param>
        /// <returns>
        /// 包含指定字符串集合中的非重复值的数组实例；如果输入的集合为Null或者为空，则返回空数组
        /// </returns>
        /// <remarks></remarks>
        /// <history>
        /// [zanezeng]   2008-11-18 10:32    Created
        /// </history>
        public static string[] Distinct( IEnumerable<string> values, bool ignoreCase )
        {
            //判断是否包含元素
            if (null == values || 0 == values.Count())
            {
                //返回空数组
                return EmptyStrings;
            }

            //获得比较器
            IEqualityComparer<string> comparer = (ignoreCase) ? StringComparer.CurrentCultureIgnoreCase : StringComparer.CurrentCulture;

            //消除重复值
            IEnumerable<string> result = values.Distinct( comparer );

            //返回
            return result.ToArray();
        }

        /// <summary>
        /// 消除指定字符串集合中的重复值
        /// </summary>
        /// <param name="values">需要消除重复值的字符串集合</param>
        /// <param name="comparer">字符串相当比较器</param>
        /// <returns>
        /// 包含指定字符串集合中的非重复值的数组实例；如果输入的集合为Null或者为空，则返回空数组
        /// </returns>
        /// <remarks></remarks>
        /// <exception cref="System.ArgumentNullException"><paramref name="comparer"/>为Null</exception>
        /// <history>
        /// [zanezeng]   2008-11-18 10:32    Created
        /// </history>
        public static string[] Distinct( IEnumerable<string> values, IEqualityComparer<string> comparer )
        {
            //断言参数
            ArgumentAssert.AssertArgumentNotNull( comparer, "compare" );

            //判断是否包含元素
            if (null == values || 0 == values.Count())
            {
                //返回空数组
                return EmptyStrings;
            }

            //消除重复值
            IEnumerable<string> result = values.Distinct( comparer );

            //返回
            return result.ToArray();
        }

        #endregion

        #region ---Const

        /// <summary>
        /// 默认的限定字符串分隔符
        /// </summary>
        private const char DEFAULT_SEPARATOR = '.';

        /// <summary>
        /// 空白字符
        /// </summary>
        private const char SPACE = ' ';

        /// <summary>
        /// 默认的限定符
        /// </summary>
        private const char DEFAULT_QUALIFIER = '\'';

        /// <summary>
        /// 空白数组
        /// </summary>
        private static readonly string[] s_EmptyStrings = new string[0];

        /// <summary>
        /// 空白字符
        /// </summary>
        private static readonly char[] WHITESPACECHARS = new char[] 
        {
            '\t', '\n', '\v', '\f', '\r',
            ' ', '\x0085', '\x00a0', '\u1680', '\u2000',
            '\u2001', '\u2002', '\u2003', '\u2004', '\u2005', 
            '\u2006', '\u2007', '\u2008', '\u2009', '\u200a', 
            '\u200b', '\u2028', '\u2029', '\u3000', '\ufeff'
        };

        /// <summary>
        /// URI路径段之间的分割符
        /// </summary>
        public const string URI_SEGMENT_SEPARATOR = "/";

        /// <summary>
        /// 路径之间的分割符
        /// </summary>
        public const string PATH_SEPARATOR = ",";

        #endregion
    }
}